# Creative Blockchain — OUSD mega-prompts (Base, mainnet only)
994 self-contained Lovable mega-prompts. Source: https://arcprompts.lovable.app
OUSD contracts: Base 0xB2000000000000000000002fEb517dFeC7415344 · Ethereum 0x9f6F3991D525015a6F8CaF062C83b62fD3AC4436 · Solana ousd2mJsPEckLHcSCDxyKD7NDGARZcfLbDZkKiatYHB · Tempo 0x20c0000000000000000000006a37DA5C996874BE

===== SKILL chains.md =====

# Chains

## Base

- `import { base } from "viem/chains"` → Privy `defaultChain` and `supportedChains`.
- OUSD is an ERC-20. Send `transfer(to, amount)` encoded with viem `erc20Abi`, `value: 0n`, to the OUSD contract.
- Cheapest EVM option. Enable Base in Privy → Gas Sponsorship and pass `{ sponsor: true }`.

## Ethereum

- `import { mainnet } from "viem/chains"`.
- Same ERC-20 pattern as Base. Gas is expensive: sponsor it or show the estimated fee in USD before confirm.
- Public RPCs rate-limit. Keep an Alchemy/Infura URL in a server-only secret and proxy reads.

## Solana

- OUSD mint: `ousd2mJsPEckLHcSCDxyKD7NDGARZcfLbDZkKiatYHB`.
- Fetch the mint account and use its `owner` as the token program id (classic Token or Token-2022).
- Transfer: `getAssociatedTokenAddressSync(mint, owner, false, programId)` for both sides, prepend `createAssociatedTokenAccountIdempotentInstruction` for the recipient, then `createTransferCheckedInstruction(src, mint, dst, owner, amount, decimals, [], programId)`.
- The public RPC is rate-limited — use `SOLANA_RPC_URL` (Helius/Alchemy) on the server.

## Tempo

```ts
import { defineChain } from "viem";
export const tempo = defineChain({
  id: 4217,
  name: "Tempo",
  nativeCurrency: { name: "USD", symbol: "USD", decimals: 6 },
  rpcUrls: { default: { http: ["https://rpc.tempo.xyz"] } },
  blockExplorers: { default: { name: "Tempo Explorer", url: "https://explore.tempo.xyz" } },
});
```

- Confirm the RPC URL at docs.tempo.xyz before shipping.
- Native value transfers revert. OUSD is TIP-20: `transfer(to, amount)` on the OUSD address, `value: 0n`.
- Explorer path is `/receipt/<hash>`, not `/tx/<hash>`.
- Pass the same `defineChain` object to Privy `defaultChain` and `supportedChains` — a stub breaks the wallet.

===== SKILL compliance.md =====

# Compliance

Source: [Geo restrictions and prohibited use cases](https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases).

## Geo restrictions

OUSD may not be promoted in: the European Economic Area, Afghanistan, Belarus, DR Congo, Cuba, Gaza Strip, Iran, Iraq, Lebanon, Libya, Myanmar, North Korea, Russia, Somalia, South Sudan, Sudan, Syria, occupied Ukrainian territories (Crimea, Sevastopol, Donetsk, Kherson, Luhansk, Zaporizhzhia), Venezuela, West Bank and Yemen.

Every app shows a footer notice linking to the page above.

## Prohibited use cases

Adult content, bail bonds, cannabis, check cashing, collections agencies, counterfeit goods, fraud, gambling, games of chance, IP infringement, jewelry, lotteries, luxury goods, mixing, multi-level marketing, pharmaceuticals, precious metals, safe deposit boxes, drug-mimicking substances, sweepstakes, tobacco, unfair or deceptive practices, unlawful activity, unlawful prediction markets, watches and weapons.

Ideas in these categories are removed from this archive. Do not build them.

===== SKILL failure-modes.md =====

# Failure modes

| Symptom | Cause | Fix |
| --- | --- | --- |
| Page crashes on load | Privy imported at the top of a route | Lazy-load inside `<ClientOnly>` |
| Secret form rejects the name | `VITE_*` prefix | Name it `PRIVY_APP_ID`, read in a route loader |
| Tempo explorer link 404s | Used `/tx/<hash>` | Use `/receipt/<hash>` |
| Tempo send reverts | Non-zero `value` | TIP-20 `transfer`, `value: 0n` |
| Tempo send hangs forever | Client transactions disabled in Privy | Enable it; add a 45s timeout |
| "Insufficient funds" with OUSD balance | No gas sponsorship | Enable chain in Privy Gas Sponsorship + `sponsor: true` |
| Amount off by 10^12 | Hardcoded 18 decimals | Read `decimals()` / `getMint` |
| Solana transfer fails "invalid program" | Wrong token program | Use the mint account's `owner` as program id |
| Solana recipient has no account | Missing ATA | Prepend idempotent ATA create instruction |
| 429 errors | Public RPC rate limit | Server-only RPC secret, proxy via server function |
| Success shown but nothing on explorer | Didn't wait for confirmation | `waitForTransactionReceipt` / `confirmTransaction` first |

===== SKILL overview.md =====

---
name: lovable-ousd
description: Build Lovable apps that pay, split and prove with OUSD (Open USD) on Base, Ethereum, Solana and Tempo mainnet using Privy embedded wallets. Use for any OUSD, Open Standard, Bridge stablecoin, or multi-chain stablecoin payment request.
---

# Lovable OUSD skill

OUSD (Open USD) is a USD stablecoin issued by Bridge (a Stripe company) and governed by Open Standard. It went live on 30 September 2026 and is native on four chains. **Mainnet only — there is no testnet.**

## Official OUSD addresses

| Chain | OUSD address | Explorer tx link |
| --- | --- | --- |
| Base (8453) | `0xB2000000000000000000002fEb517dFeC7415344` | `https://basescan.org/tx/<hash>` |
| Ethereum (1) | `0x9f6F3991D525015a6F8CaF062C83b62fD3AC4436` | `https://etherscan.io/tx/<hash>` |
| Solana | `ousd2mJsPEckLHcSCDxyKD7NDGARZcfLbDZkKiatYHB` | `https://solscan.io/tx/<hash>` |
| Tempo (4217) | `0x20c0000000000000000000006a37DA5C996874BE` | `https://explore.tempo.xyz/receipt/<hash>` |

Source: [joinopenstandard.com/integrate](https://joinopenstandard.com/integrate).

## Always apply

- **No contract deploys.** OUSD is live; every feature is an OUSD transfer (EVM ERC-20 / Tempo TIP-20 / Solana SPL).
- **Privy for every chain.** Google sign-in, embedded wallets (EVM + Solana), loaded lazily inside `<ClientOnly>`.
- **Read decimals on chain.** Never hardcode them.
- **Real money.** Show "Mainnet · real OUSD" above every pay button and default to ≤ 1 OUSD.
- **Compliance footer.** OUSD is unavailable in the EEA and sanctioned regions; prohibited use cases are never built.
- **Secrets:** only `PRIVY_APP_ID` is required. Optional server-only RPC URLs (`ETHEREUM_RPC_URL`, `SOLANA_RPC_URL`). Never use a `VITE_*` secret name — read secrets in a route loader.

## Guides

- **Chains** — per-chain setup and gotchas.
- **Privy wallets** — provider config for EVM + Solana and gas sponsorship.
- **Payments** — pay, split, tip and provenance patterns.
- **Compliance** — geo restrictions and prohibited use cases.
- **Failure modes** — symptoms and fixes.

## Getting OUSD

Through integration partners (Stripe / Bridge / Privy, Coinbase, Visa, Mastercard — all mint and burn 1:1 with USD at no cost) or exchanges (Coinbase, Kraken, Uniswap).

===== SKILL payments.md =====

# Payments

Every pattern is: **check balance → confirm → send → wait for confirmation → show explorer link.**

| Pattern | What happens |
| --- | --- |
| Pay | One OUSD transfer from buyer to creator. |
| Split | One payment, several sequential transfers by percentage. Show each with its own link; if one fails, show which shares are still owed. |
| Tip | Small fixed amount (e.g. 0.10 OUSD) after an action. |
| Provenance | The confirmed tx hash is the proof. Save buyer, price, time and hash; render a certificate linking to the explorer. |

## Amounts

- Convert with on-chain decimals: `parseUnits("1.00", decimals)`.
- Display 2 decimals. Default demo amounts ≤ 1 OUSD — this is real money.

## Not enough OUSD

Show a "Get OUSD" button linking to [joinopenstandard.com/integrate](https://joinopenstandard.com/integrate) (Stripe / Bridge / Privy, Coinbase, Visa, Mastercard, or Coinbase / Kraken / Uniswap).

## Wrong network

Refuse to send and show "Switch to <chain>". Never retry silently on another chain.

## Reference code (generated)

These are the exact snippets every mega-prompt embeds.


### Base

```tsx
// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).
```

### Ethereum

```tsx
// src/lib/ousd.ts
import { mainnet as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0x9f6F3991D525015a6F8CaF062C83b62fD3AC4436' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://ethereum-rpc.publicnode.com') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://etherscan.io/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).
```

### Solana

```tsx
// src/lib/ousd.ts
import { Connection, PublicKey, Transaction } from '@solana/web3.js';
import { getMint, getAssociatedTokenAddressSync, createAssociatedTokenAccountIdempotentInstruction,
  createTransferCheckedInstruction, getAccount } from '@solana/spl-token';
export const MINT = new PublicKey('ousd2mJsPEckLHcSCDxyKD7NDGARZcfLbDZkKiatYHB');
export const conn = new Connection('https://api.mainnet-beta.solana.com', 'confirmed'); // swap for a proxied SOLANA_RPC_URL in production
let meta: { programId: PublicKey; decimals: number } | undefined;
export async function mintMeta() {
  if (meta) return meta;
  const info = await conn.getAccountInfo(MINT); const programId = info!.owner; // Token or Token-2022
  const m = await getMint(conn, MINT, 'confirmed', programId);
  return (meta = { programId, decimals: m.decimals });
}
export async function ousdBalance(owner: string) {
  const { programId, decimals } = await mintMeta();
  const ata = getAssociatedTokenAddressSync(MINT, new PublicKey(owner), false, programId);
  try { const a = await getAccount(conn, ata, 'confirmed', programId); return Number(a.amount) / 10 ** decimals; }
  catch { return 0; } // no token account yet
}
export async function transferTx(from: string, to: string, amount: number) {
  const { programId, decimals } = await mintMeta();
  const f = new PublicKey(from), t = new PublicKey(to);
  const src = getAssociatedTokenAddressSync(MINT, f, false, programId);
  const dst = getAssociatedTokenAddressSync(MINT, t, false, programId);
  const tx = new Transaction().add(
    createAssociatedTokenAccountIdempotentInstruction(f, dst, t, MINT, programId),
    createTransferCheckedInstruction(src, MINT, dst, f, BigInt(Math.round(amount * 10 ** decimals)), decimals, [], programId));
  tx.feePayer = f; tx.recentBlockhash = (await conn.getLatestBlockhash()).blockhash;
  return tx.serialize({ requireAllSignatures: false });
}
export const txUrl = (sig: string) => 'https://solscan.io/tx/' + sig;

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'],
    embeddedWallets: { solana: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending: const { wallets } = useWallets() and const { signAndSendTransaction } = useSignAndSendTransaction()
// (both from '@privy-io/react-auth/solana'); const bytes = await transferTx(wallets[0].address, to, 1);
// const { signature } = await signAndSendTransaction({ transaction: bytes, wallet: wallets[0] });
// convert signature to base58 (bs58) if it is bytes, await conn.confirmTransaction, then show txUrl.
```

### Tempo

```tsx
// src/lib/ousd.ts
import { defineChain } from 'viem';
export const CHAIN = defineChain({ id: 4217, name: 'Tempo',
  nativeCurrency: { name: 'USD', symbol: 'USD', decimals: 6 },
  rpcUrls: { default: { http: ['https://rpc.tempo.xyz'] } } }); // confirm RPC at docs.tempo.xyz
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0x20c0000000000000000000006a37DA5C996874BE' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://rpc.tempo.xyz') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://explore.tempo.xyz/receipt/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).
```

===== SKILL privy-wallets.md =====

# Privy wallets

## Mounting

`@privy-io/react-auth` crashes during server rendering. Load it with `React.lazy(() => import("./privy-root"))` inside `<ClientOnly>` + `<Suspense>`. Never import it at the top of a route file.

Read `PRIVY_APP_ID` with a server function in a route loader and pass it down. Lovable rejects `VITE_*` secret names.

## EVM (Base, Ethereum, Tempo)

```tsx
<PrivyProvider
  appId={appId}
  config={{
    loginMethods: ["google", "email"],
    embeddedWallets: { ethereum: { createOnLogin: "users-without-wallets" } },
    defaultChain: chain,
    supportedChains: [chain],
  }}
>
```

Send with `useSendTransaction()`:

```ts
await sendTransaction(
  { to: OUSD, data: encodeFunctionData({ abi: erc20Abi, functionName: "transfer", args: [to, amount] }), value: 0n, chainId },
  { address: wallet.address, sponsor: true },
);
```

## Solana

```tsx
embeddedWallets: { solana: { createOnLogin: "users-without-wallets" } }
```

Build the transfer transaction (see Chains) and send it with `useSignAndSendTransaction` from `@privy-io/react-auth/solana`. Check the Privy docs for your installed version — the Solana hooks moved between major releases.

## Dashboard checklist

1. Add the preview and published domains to Allowed origins.
2. Enable the chain under Gas Sponsorship (Base, Ethereum, Tempo, Solana as needed).
3. For Tempo, enable "Allow transactions from the client" — otherwise `sendTransaction` hangs silently.


===== IDEA dance-choreo-ledger-0 · Base · Choreo Ledger =====
Page: https://arcprompts.lovable.app/ideas/dance-choreo-ledger-0

Build "Choreo Ledger" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Securely prove original choreography ownership and timestamp creations on a public ledger.
Discipline: Dance & Choreography (movement attribution). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a movement attribution item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The movement attribution flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA dance-dance-nft-tickets-1 · Base · Dance NFT Tickets =====
Page: https://arcprompts.lovable.app/ideas/dance-dance-nft-tickets-1

Build "Dance NFT Tickets" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Sell and verify exclusive dance event tickets as tradable NFTs on-chain to prevent fraud.
Discipline: Dance & Choreography (event access control). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a event access control item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The event access control flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA dance-movecoin-rewards-2 · Base · MoveCoin Rewards =====
Page: https://arcprompts.lovable.app/ideas/dance-movecoin-rewards-2

Build "MoveCoin Rewards" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Reward dancers with crypto tokens for participation and achievements in studio classes.
Discipline: Dance & Choreography (incentive tokenization). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a incentive tokenization item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The incentive tokenization flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA dance-choreo-royalty-pool-3 · Base · Choreo Royalty Pool =====
Page: https://arcprompts.lovable.app/ideas/dance-choreo-royalty-pool-3

Build "Choreo Royalty Pool" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Distribute royalties automatically among choreographers, dancers, and producers using smart contracts.
Discipline: Dance & Choreography (rights management). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a rights management item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The rights management flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA dance-syncstage-auction-4 · Base · SyncStage Auction =====
Page: https://arcprompts.lovable.app/ideas/dance-syncstage-auction-4

Build "SyncStage Auction" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Auction live dance performance slots to global choreographers via transparent smart contracts.
Discipline: Dance & Choreography (live collaboration). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a live collaboration item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The live collaboration flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA dance-moveproof-ledger-5 · Base · MoveProof Ledger =====
Page: https://arcprompts.lovable.app/ideas/dance-moveproof-ledger-5

Build "MoveProof Ledger" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Record and verify unique dance moves proof-of-existence onchain to counter plagiarism.
Discipline: Dance & Choreography (movement authenticity). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a movement authenticity item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The movement authenticity flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA dance-tokenized-choreo-kits-6 · Base · Tokenized Choreo Kits =====
Page: https://arcprompts.lovable.app/ideas/dance-tokenized-choreo-kits-6

Build "Tokenized Choreo Kits" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Sell bundled choreography sequences as tokenized assets for easier licensing and resale.
Discipline: Dance & Choreography (content packaging). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a content packaging item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The content packaging flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA dance-dancedao-collective-7 · Base · DanceDAO Collective =====
Page: https://arcprompts.lovable.app/ideas/dance-dancedao-collective-7

Build "DanceDAO Collective" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Enable dance groups to govern studios and projects democratically via onchain voting.
Discipline: Dance & Choreography (community governance). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a community governance item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The community governance flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA dance-nft-move-badges-8 · Base · NFT Move Badges =====
Page: https://arcprompts.lovable.app/ideas/dance-nft-move-badges-8

Build "NFT Move Badges" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Issue unique NFT badges for dance milestones and skills to motivate learners.
Discipline: Dance & Choreography (achievement tracking). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a achievement tracking item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The achievement tracking flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA dance-choreo-licensing-hub-9 · Base · Choreo Licensing Hub =====
Page: https://arcprompts.lovable.app/ideas/dance-choreo-licensing-hub-9

Build "Choreo Licensing Hub" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Create a decentralized marketplace for buying and selling choreography licenses directly onchain.
Discipline: Dance & Choreography (rights marketplace). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a rights marketplace item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The rights marketplace flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA dance-dancemove-provenance-10 · Base · DanceMove Provenance =====
Page: https://arcprompts.lovable.app/ideas/dance-dancemove-provenance-10

Build "DanceMove Provenance" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Trace and display the lineage and remix history of dance moves on an immutable ledger.
Discipline: Dance & Choreography (creative lineage). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a creative lineage item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The creative lineage flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA dance-livemotion-payments-11 · Base · LiveMotion Payments =====
Page: https://arcprompts.lovable.app/ideas/dance-livemotion-payments-11

Build "LiveMotion Payments" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Settle payments instantly for live dance services and gigs through smart contracts.
Discipline: Dance & Choreography (instant settlement). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a instant settlement item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The instant settlement flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA dance-choreocrowd-fund-12 · Base · ChoreoCrowd Fund =====
Page: https://arcprompts.lovable.app/ideas/dance-choreocrowd-fund-12

Build "ChoreoCrowd Fund" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Enable transparent onchain fundraising for dance projects with milestones and payout automation.
Discipline: Dance & Choreography (project crowdfunding). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a project crowdfunding item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The project crowdfunding flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA dance-dancestep-identity-13 · Base · DanceStep Identity =====
Page: https://arcprompts.lovable.app/ideas/dance-dancestep-identity-13

Build "DanceStep Identity" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Create verifiable digital identities for dancers' skills and experiences stored onchain.
Discipline: Dance & Choreography (digital identity). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a digital identity item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The digital identity flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA dance-choreoswap-marketplace-14 · Base · ChoreoSwap Marketplace =====
Page: https://arcprompts.lovable.app/ideas/dance-choreoswap-marketplace-14

Build "ChoreoSwap Marketplace" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Swap choreography clips and movement motifs peer-to-peer as tokenized assets onchain.
Discipline: Dance & Choreography (content exchange). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a content exchange item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The content exchange flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA dance-movemint-workshops-15 · Base · MoveMint Workshops =====
Page: https://arcprompts.lovable.app/ideas/dance-movemint-workshops-15

Build "MoveMint Workshops" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint limited access tokens to exclusive dance workshops and masterclasses as NFTs.
Discipline: Dance & Choreography (tokenized education). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a tokenized education item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The tokenized education flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA dance-stepchain-voting-16 · Base · StepChain Voting =====
Page: https://arcprompts.lovable.app/ideas/dance-stepchain-voting-16

Build "StepChain Voting" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Let audiences vote transparently and fairly on dance competition outcomes via smart contracts.
Discipline: Dance & Choreography (event curation). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a event curation item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The event curation flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA dance-choreoproof-licensing-17 · Base · ChoreoProof Licensing =====
Page: https://arcprompts.lovable.app/ideas/dance-choreoproof-licensing-17

Build "ChoreoProof Licensing" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Automate licensing agreements for choreography use with onchain smart contract enforcement.
Discipline: Dance & Choreography (automated contracts). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a automated contracts item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The automated contracts flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA dance-dancetoken-staking-18 · Base · DanceToken Staking =====
Page: https://arcprompts.lovable.app/ideas/dance-dancetoken-staking-18

Build "DanceToken Staking" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Stake tokens to support favorite dancers and receive exclusive perks or content rewards.
Discipline: Dance & Choreography (community incentives). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a community incentives item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The community incentives flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA dance-stepswap-royalties-19 · Base · StepSwap Royalties =====
Page: https://arcprompts.lovable.app/ideas/dance-stepswap-royalties-19

Build "StepSwap Royalties" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Track and enforce royalty payments on resales of choreography NFTs via smart contracts.
Discipline: Dance & Choreography (resale tracking). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a resale tracking item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The resale tracking flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA dance-danceledger-archives-20 · Base · DanceLedger Archives =====
Page: https://arcprompts.lovable.app/ideas/dance-danceledger-archives-20

Build "DanceLedger Archives" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Archive dance event records and performances permanently on a public blockchain ledger.
Discipline: Dance & Choreography (historical record). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a historical record item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The historical record flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA dance-choreominting-platform-21 · Base · ChoreoMinting Platform =====
Page: https://arcprompts.lovable.app/ideas/dance-choreominting-platform-21

Build "ChoreoMinting Platform" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Empower dancers to mint and sell unique choreography NFTs directly from studios.
Discipline: Dance & Choreography (NFT creation). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a NFT creation item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The NFT creation flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA dance-tokenmove-sponsorship-22 · Base · TokenMove Sponsorship =====
Page: https://arcprompts.lovable.app/ideas/dance-tokenmove-sponsorship-22

Build "TokenMove Sponsorship" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Enable brands to sponsor dancers directly through programmable tokens and onchain contracts.
Discipline: Dance & Choreography (brand engagement). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a brand engagement item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The brand engagement flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA dance-crowddance-licensing-23 · Base · CrowdDance Licensing =====
Page: https://arcprompts.lovable.app/ideas/dance-crowddance-licensing-23

Build "CrowdDance Licensing" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
License remixed choreography created by crowdsourced dancers with onchain rights management.
Discipline: Dance & Choreography (mass collaboration). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a mass collaboration item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The mass collaboration flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA dance-danceswap-collaborations-24 · Base · DanceSwap Collaborations =====
Page: https://arcprompts.lovable.app/ideas/dance-danceswap-collaborations-24

Build "DanceSwap Collaborations" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Facilitate peer-to-peer choreography collaboration and revenue sharing via smart contracts.
Discipline: Dance & Choreography (peer collaboration). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a peer collaboration item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The peer collaboration flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA dance-choreo-sequence-vault-0 · Base · Choreo Sequence Vault =====
Page: https://arcprompts.lovable.app/ideas/dance-choreo-sequence-vault-0

Build "Choreo Sequence Vault" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Securely store and share choreographic sequences as immutable IPFS manifests for global access.
Discipline: Dance & Choreography (dance notation archiving). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a dance notation archiving sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The dance notation archiving flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA dance-movement-moodboard-1 · Base · Movement Moodboard =====
Page: https://arcprompts.lovable.app/ideas/dance-movement-moodboard-1

Build "Movement Moodboard" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Create and pin curated dance inspiration boards with images and JSON metadata on IPFS.
Discipline: Dance & Choreography (dance inspiration boards). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a dance inspiration boards sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The dance inspiration boards flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA dance-dance-nft-gallery-2 · Base · Dance NFT Gallery =====
Page: https://arcprompts.lovable.app/ideas/dance-dance-nft-gallery-2

Build "Dance NFT Gallery" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Artists mint and pin digital dance art portfolios as NFTs stored forever on IPFS.
Discipline: Dance & Choreography (digital dance art). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a digital dance art sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The digital dance art flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA dance-choreographer-s-ledger-3 · Base · Choreographer’s Ledger =====
Page: https://arcprompts.lovable.app/ideas/dance-choreographer-s-ledger-3

Build "Choreographer’s Ledger" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Record choreography permissions and usage rights as JSON manifests pinned on IPFS.
Discipline: Dance & Choreography (IP rights management). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a IP rights management sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The IP rights management flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA dance-technique-archive-hub-4 · Base · Technique Archive Hub =====
Page: https://arcprompts.lovable.app/ideas/dance-technique-archive-hub-4

Build "Technique Archive Hub" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin and share detailed dance technique manuals and videos as permanent IPFS content.
Discipline: Dance & Choreography (dance training materials). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a dance training materials sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The dance training materials flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA dance-movement-metadata-mapper-5 · Base · Movement Metadata Mapper =====
Page: https://arcprompts.lovable.app/ideas/dance-movement-metadata-mapper-5

Build "Movement Metadata Mapper" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Attach rich JSON metadata to dance performance images pinned via IPFS for enhanced searchability.
Discipline: Dance & Choreography (dance data annotation). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a dance data annotation sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The dance data annotation flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA dance-global-dance-archive-6 · Base · Global Dance Archive =====
Page: https://arcprompts.lovable.app/ideas/dance-global-dance-archive-6

Build "Global Dance Archive" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Digitize and pin cultural dance archives on IPFS preserving global dance heritage forever.
Discipline: Dance & Choreography (dance heritage preservation). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a dance heritage preservation sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The dance heritage preservation flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA dance-collaborative-choreo-file-7 · Base · Collaborative Choreo File =====
Page: https://arcprompts.lovable.app/ideas/dance-collaborative-choreo-file-7

Build "Collaborative Choreo File" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Teams pin evolving choreography JSON manifests on IPFS for real-time, decentralized collaboration.
Discipline: Dance & Choreography (group choreography workflow). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a group choreography workflow sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The group choreography workflow flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA dance-dance-move-tokens-8 · Base · Dance Move Tokens =====
Page: https://arcprompts.lovable.app/ideas/dance-dance-move-tokens-8

Build "Dance Move Tokens" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Create, pin, and trade unique dance moves with JSON metadata on IPFS representing rights.
Discipline: Dance & Choreography (movement licensing). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a movement licensing sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The movement licensing flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA dance-virtual-rehearsal-logs-9 · Base · Virtual Rehearsal Logs =====
Page: https://arcprompts.lovable.app/ideas/dance-virtual-rehearsal-logs-9

Build "Virtual Rehearsal Logs" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin JSON logs of rehearsal notes and images on IPFS for permanent, shareable practice records.
Discipline: Dance & Choreography (practice session tracking). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a practice session tracking sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The practice session tracking flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA dance-interactive-dance-maps-10 · Base · Interactive Dance Maps =====
Page: https://arcprompts.lovable.app/ideas/dance-interactive-dance-maps-10

Build "Interactive Dance Maps" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin visual and JSON data of choreography spatial maps on IPFS for decentralized access and reuse.
Discipline: Dance & Choreography (movement spatialization). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a movement spatialization sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The movement spatialization flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA dance-ai-dance-dataset-repository-11 · Base · AI Dance Dataset Repository =====
Page: https://arcprompts.lovable.app/ideas/dance-ai-dance-dataset-repository-11

Build "AI Dance Dataset Repository" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin curated datasets of labeled dance images and JSON metadata on IPFS for AI training.
Discipline: Dance & Choreography (machine learning data). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a machine learning data sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The machine learning data flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA dance-dance-festival-archive-12 · Base · Dance Festival Archive =====
Page: https://arcprompts.lovable.app/ideas/dance-dance-festival-archive-12

Build "Dance Festival Archive" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin photos and JSON manifests of live dance festival performances on IPFS for posterity and access.
Discipline: Dance & Choreography (event documentation). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a event documentation sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The event documentation flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA dance-costume-design-catalog-13 · Base · Costume Design Catalog =====
Page: https://arcprompts.lovable.app/ideas/dance-costume-design-catalog-13

Build "Costume Design Catalog" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin images and JSON design manifests of dance costumes on IPFS for long-term design preservation.
Discipline: Dance & Choreography (dance wardrobe archives). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a dance wardrobe archives sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The dance wardrobe archives flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA dance-movement-emotion-tags-14 · Base · Movement Emotion Tags =====
Page: https://arcprompts.lovable.app/ideas/dance-movement-emotion-tags-14

Build "Movement Emotion Tags" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin emotionally tagged dance movement metadata on IPFS to enhance creative interpretative tools.
Discipline: Dance & Choreography (affective annotation). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a affective annotation sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The affective annotation flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA dance-dance-challenge-repository-15 · Base · Dance Challenge Repository =====
Page: https://arcprompts.lovable.app/ideas/dance-dance-challenge-repository-15

Build "Dance Challenge Repository" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin community dance challenge videos and JSON instructions on IPFS for global participation.
Discipline: Dance & Choreography (community choreography). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a community choreography sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The community choreography flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA dance-movement-style-index-16 · Base · Movement Style Index =====
Page: https://arcprompts.lovable.app/ideas/dance-movement-style-index-16

Build "Movement Style Index" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin genre-classified dance move datasets with JSON metadata on IPFS for style machine parsing.
Discipline: Dance & Choreography (genre classification). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a genre classification sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The genre classification flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA dance-live-choreo-snapshot-17 · Base · Live Choreo Snapshot =====
Page: https://arcprompts.lovable.app/ideas/dance-live-choreo-snapshot-17

Build "Live Choreo Snapshot" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin image and JSON snapshots of live choreography moments on IPFS for historical timestamping.
Discipline: Dance & Choreography (performance capture). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a performance capture sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The performance capture flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA dance-dance-studio-portfolio-18 · Base · Dance Studio Portfolio =====
Page: https://arcprompts.lovable.app/ideas/dance-dance-studio-portfolio-18

Build "Dance Studio Portfolio" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Studios pin portfolios of images and JSON class manifests on IPFS to showcase offerings forever.
Discipline: Dance & Choreography (business marketing). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a business marketing sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The business marketing flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA dance-choreography-remix-log-19 · Base · Choreography Remix Log =====
Page: https://arcprompts.lovable.app/ideas/dance-choreography-remix-log-19

Build "Choreography Remix Log" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin JSON manifests of choreographic remixes and images on IPFS to document creative lineage.
Discipline: Dance & Choreography (creative versioning). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a creative versioning sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The creative versioning flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA dance-dance-props-inventory-20 · Base · Dance Props Inventory =====
Page: https://arcprompts.lovable.app/ideas/dance-dance-props-inventory-20

Build "Dance Props Inventory" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin images and JSON manifests of dance prop inventories to IPFS for decentralized sharing.
Discipline: Dance & Choreography (production resource management). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a production resource management sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The production resource management flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA dance-movement-annotation-tool-21 · Base · Movement Annotation Tool =====
Page: https://arcprompts.lovable.app/ideas/dance-movement-annotation-tool-21

Build "Movement Annotation Tool" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin annotated movement images and JSON metadata on IPFS to support global dance research.
Discipline: Dance & Choreography (dance research). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a dance research sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The dance research flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA dance-dance-therapy-logs-22 · Base · Dance Therapy Logs =====
Page: https://arcprompts.lovable.app/ideas/dance-dance-therapy-logs-22

Build "Dance Therapy Logs" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin JSON and image records of dance therapy sessions on IPFS for secure patient histories.
Discipline: Dance & Choreography (health documentation). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a health documentation sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The health documentation flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA dance-interactive-step-manuals-23 · Base · Interactive Step Manuals =====
Page: https://arcprompts.lovable.app/ideas/dance-interactive-step-manuals-23

Build "Interactive Step Manuals" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin interactive dance step image guides plus JSON instructions on IPFS for teacher-student use.
Discipline: Dance & Choreography (teaching aids). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a teaching aids sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The teaching aids flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA dance-movement-patent-registry-24 · Base · Movement Patent Registry =====
Page: https://arcprompts.lovable.app/ideas/dance-movement-patent-registry-24

Build "Movement Patent Registry" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin JSON manifests documenting novel dance moves on IPFS to certify original creation dates.
Discipline: Dance & Choreography (innovation tracking). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a innovation tracking sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The innovation tracking flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA dance-gasless-dance-battles-0 · Base · Gasless Dance Battles =====
Page: https://arcprompts.lovable.app/ideas/dance-gasless-dance-battles-0

Build "Gasless Dance Battles" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Enable dancers to join and sponsor dance battles without paying gas fees.
Discipline: Dance & Choreography (competitive choreography). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a competitive choreography action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The competitive choreography flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA dance-choreo-nft-vault-1 · Base · Choreo NFT Vault =====
Page: https://arcprompts.lovable.app/ideas/dance-choreo-nft-vault-1

Build "Choreo NFT Vault" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Securely store and share choreography as NFTs without users handling gas payments.
Discipline: Dance & Choreography (digital choreography ownership). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a digital choreography ownership action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The digital choreography ownership flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA dance-studio-access-club-2 · Base · Studio Access Club =====
Page: https://arcprompts.lovable.app/ideas/dance-studio-access-club-2

Build "Studio Access Club" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Create token-gated memberships for dance studios with seamless gas-free onboarding.
Discipline: Dance & Choreography (membership management). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a membership management action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The membership management flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA dance-movement-royalty-tracker-3 · Base · Movement Royalty Tracker =====
Page: https://arcprompts.lovable.app/ideas/dance-movement-royalty-tracker-3

Build "Movement Royalty Tracker" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Automatically track and reward choreographers when their moves get used commercially.
Discipline: Dance & Choreography (usage rights). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a usage rights action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The usage rights flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA dance-gas-free-dance-voting-4 · Base · Gas-Free Dance Voting =====
Page: https://arcprompts.lovable.app/ideas/dance-gas-free-dance-voting-4

Build "Gas-Free Dance Voting" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Host dance community polls and awards with zero gas cost for voters.
Discipline: Dance & Choreography (community decision-making). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a community decision-making action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The community decision-making flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA dance-choreo-collaboration-hub-5 · Base · Choreo Collaboration Hub =====
Page: https://arcprompts.lovable.app/ideas/dance-choreo-collaboration-hub-5

Build "Choreo Collaboration Hub" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Facilitate collaborative dance projects with blockchain-secured contribution records, gas-free.
Discipline: Dance & Choreography (joint choreography creation). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a joint choreography creation action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The joint choreography creation flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA dance-dance-event-tickets-6 · Base · Dance Event Tickets =====
Page: https://arcprompts.lovable.app/ideas/dance-dance-event-tickets-6

Build "Dance Event Tickets" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Sell and distribute dance event tickets as NFTs with no gas for buyers.
Discipline: Dance & Choreography (ticketing system). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a ticketing system action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The ticketing system flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA dance-gasless-dance-royalties-7 · Base · Gasless Dance Royalties =====
Page: https://arcprompts.lovable.app/ideas/dance-gasless-dance-royalties-7

Build "Gasless Dance Royalties" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pay royalties to dancers and choreographers instantly with no transaction fees.
Discipline: Dance & Choreography (automatic payments). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a automatic payments action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The automatic payments flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA dance-dance-move-provenance-8 · Base · Dance Move Provenance =====
Page: https://arcprompts.lovable.app/ideas/dance-dance-move-provenance-8

Build "Dance Move Provenance" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Verify authenticity and origin of iconic dance moves onchain, gaslessly.
Discipline: Dance & Choreography (authenticity verification). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a authenticity verification action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The authenticity verification flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA dance-gas-free-dance-workshops-9 · Base · Gas-Free Dance Workshops =====
Page: https://arcprompts.lovable.app/ideas/dance-gas-free-dance-workshops-9

Build "Gas-Free Dance Workshops" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Enroll and attend dance workshops with blockchain-secured certificates, no gas fees.
Discipline: Dance & Choreography (online learning). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a online learning action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The online learning flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA dance-choreo-token-rewards-10 · Base · Choreo Token Rewards =====
Page: https://arcprompts.lovable.app/ideas/dance-choreo-token-rewards-10

Build "Choreo Token Rewards" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Reward choreographers with tokens for popular routines without requiring gas payments.
Discipline: Dance & Choreography (creator incentives). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a creator incentives action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The creator incentives flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA dance-dance-gear-marketplace-11 · Base · Dance Gear Marketplace =====
Page: https://arcprompts.lovable.app/ideas/dance-dance-gear-marketplace-11

Build "Dance Gear Marketplace" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Buy and sell dance apparel and gear as NFTs with gasless transaction experience.
Discipline: Dance & Choreography (digital commerce). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a digital commerce action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The digital commerce flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA dance-movement-data-wallet-12 · Base · Movement Data Wallet =====
Page: https://arcprompts.lovable.app/ideas/dance-movement-data-wallet-12

Build "Movement Data Wallet" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Securely store and share movement data NFTs with no blockchain fees for dancers.
Discipline: Dance & Choreography (performance analytics). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a performance analytics action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The performance analytics flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA dance-gasless-dance-challenges-13 · Base · Gasless Dance Challenges =====
Page: https://arcprompts.lovable.app/ideas/dance-gasless-dance-challenges-13

Build "Gasless Dance Challenges" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Launch viral dance challenges with onchain proof and no gas cost for participants.
Discipline: Dance & Choreography (social engagement). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a social engagement action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The social engagement flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA dance-dance-nft-gallery-14 · Base · Dance NFT Gallery =====
Page: https://arcprompts.lovable.app/ideas/dance-dance-nft-gallery-14

Build "Dance NFT Gallery" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Host curated dance NFT galleries that users can explore without paying gas.
Discipline: Dance & Choreography (exhibition curation). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a exhibition curation action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The exhibition curation flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA dance-choreography-licensing-hub-15 · Base · Choreography Licensing Hub =====
Page: https://arcprompts.lovable.app/ideas/dance-choreography-licensing-hub-15

Build "Choreography Licensing Hub" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
License dance routines with transparent blockchain contracts and gasless transactions.
Discipline: Dance & Choreography (rights management). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a rights management action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The rights management flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA dance-gas-free-dance-nfts-16 · Base · Gas-Free Dance NFTs =====
Page: https://arcprompts.lovable.app/ideas/dance-gas-free-dance-nfts-16

Build "Gas-Free Dance NFTs" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint and trade unique dance moment NFTs without gas fees for fans and artists.
Discipline: Dance & Choreography (blockchain collectibles). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a blockchain collectibles action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The blockchain collectibles flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA dance-virtual-dance-studios-17 · Base · Virtual Dance Studios =====
Page: https://arcprompts.lovable.app/ideas/dance-virtual-dance-studios-17

Build "Virtual Dance Studios" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Access and customize virtual dance studios with gasless token gating.
Discipline: Dance & Choreography (metaverse dance spaces). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a metaverse dance spaces action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The metaverse dance spaces flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA dance-performance-ticket-nfts-18 · Base · Performance Ticket NFTs =====
Page: https://arcprompts.lovable.app/ideas/dance-performance-ticket-nfts-18

Build "Performance Ticket NFTs" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Issue and verify dance performance tickets as NFTs with no gas costs for attendees.
Discipline: Dance & Choreography (ticketing and access). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a ticketing and access action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The ticketing and access flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA dance-gasless-dance-socials-19 · Base · Gasless Dance Socials =====
Page: https://arcprompts.lovable.app/ideas/dance-gasless-dance-socials-19

Build "Gasless Dance Socials" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Create dance-focused social networks with token rewards and no gas transaction fees.
Discipline: Dance & Choreography (community building). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a community building action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The community building flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA dance-choreographer-profiles-20 · Base · Choreographer Profiles =====
Page: https://arcprompts.lovable.app/ideas/dance-choreographer-profiles-20

Build "Choreographer Profiles" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Build verified onchain profiles for choreographers with gasless updates and endorsements.
Discipline: Dance & Choreography (professional branding). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a professional branding action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The professional branding flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA dance-dance-nft-streaming-21 · Base · Dance NFT Streaming =====
Page: https://arcprompts.lovable.app/ideas/dance-dance-nft-streaming-21

Build "Dance NFT Streaming" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Stream exclusive dance content NFTs to fans without requiring gas payments.
Discipline: Dance & Choreography (content distribution). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a content distribution action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The content distribution flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA dance-movement-token-tips-22 · Base · Movement Token Tips =====
Page: https://arcprompts.lovable.app/ideas/dance-movement-token-tips-22

Build "Movement Token Tips" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Let fans tip dancers instantly with tokens and no gas fees.
Discipline: Dance & Choreography (fan support). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a fan support action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The fan support flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA dance-gasless-dance-analytics-23 · Base · Gasless Dance Analytics =====
Page: https://arcprompts.lovable.app/ideas/dance-gasless-dance-analytics-23

Build "Gasless Dance Analytics" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Access detailed dance performance analytics with blockchain-backed data, no gas required.
Discipline: Dance & Choreography (performance insights). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a performance insights action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The performance insights flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA dance-nft-dance-collectives-24 · Base · NFT Dance Collectives =====
Page: https://arcprompts.lovable.app/ideas/dance-nft-dance-collectives-24

Build "NFT Dance Collectives" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Form dance groups managing collective NFTs and revenue with gasless transactions.
Discipline: Dance & Choreography (group ownership). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a group ownership action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The group ownership flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA dance-choreochain-ledger-0 · Base · ChoreoChain Ledger =====
Page: https://arcprompts.lovable.app/ideas/dance-choreochain-ledger-0

Build "ChoreoChain Ledger" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Securely mint and prove original dance moves as NFTs to protect choreographers' intellectual property.
Discipline: Dance & Choreography (movement cataloging). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a movement cataloging work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The movement cataloging flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA dance-flowmotion-archive-1 · Base · FlowMotion Archive =====
Page: https://arcprompts.lovable.app/ideas/dance-flowmotion-archive-1

Build "FlowMotion Archive" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint NFTs representing detailed dance notations for preservation and easy sharing among dancers.
Discipline: Dance & Choreography (dance notation). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a dance notation work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The dance notation flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA dance-beatsync-provenance-2 · Base · BeatSync Provenance =====
Page: https://arcprompts.lovable.app/ideas/dance-beatsync-provenance-2

Build "BeatSync Provenance" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Authenticate unique dance beat patterns as NFTs for royalty-tracked reuse in choreography.
Discipline: Dance & Choreography (rhythmic innovation). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a rhythmic innovation work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The rhythmic innovation flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA dance-posemint-studio-3 · Base · PoseMint Studio =====
Page: https://arcprompts.lovable.app/ideas/dance-posemint-studio-3

Build "PoseMint Studio" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Create NFT collections of signature dance poses to license and showcase unique styles.
Discipline: Dance & Choreography (pose collections). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a pose collections work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The pose collections flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA dance-steptrace-rights-4 · Base · StepTrace Rights =====
Page: https://arcprompts.lovable.app/ideas/dance-steptrace-rights-4

Build "StepTrace Rights" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint entire step sequences as NFTs to secure choreographic rights and facilitate licensing.
Discipline: Dance & Choreography (step sequence rights). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a step sequence rights work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The step sequence rights flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA dance-mirrormove-vault-5 · Base · MirrorMove Vault =====
Page: https://arcprompts.lovable.app/ideas/dance-mirrormove-vault-5

Build "MirrorMove Vault" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
NFT dance movement tokens enable secure sharing and replication tracking of signature moves.
Discipline: Dance & Choreography (movement replication). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a movement replication work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The movement replication flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA dance-rhythmroots-nft-6 · Base · RhythmRoots NFT =====
Page: https://arcprompts.lovable.app/ideas/dance-rhythmroots-nft-6

Build "RhythmRoots NFT" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Preserve cultural dances as NFT-verified IPFS multimedia packages for global education.
Discipline: Dance & Choreography (cultural dance preservation). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a cultural dance preservation work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The cultural dance preservation flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA dance-motionflow-tokens-7 · Base · MotionFlow Tokens =====
Page: https://arcprompts.lovable.app/ideas/dance-motionflow-tokens-7

Build "MotionFlow Tokens" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint NFTs of continuous dance flows that authenticate choreography progression and originality.
Discipline: Dance & Choreography (dance flow sequences). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a dance flow sequences work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The dance flow sequences flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA dance-echodance-ledger-8 · Base · EchoDance Ledger =====
Page: https://arcprompts.lovable.app/ideas/dance-echodance-ledger-8

Build "EchoDance Ledger" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Tokenize remix rights of dance routines as NFTs to facilitate fair use and royalties.
Discipline: Dance & Choreography (dance remix rights). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a dance remix rights work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The dance remix rights flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA dance-stepsync-collectibles-9 · Base · StepSync Collectibles =====
Page: https://arcprompts.lovable.app/ideas/dance-stepsync-collectibles-9

Build "StepSync Collectibles" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Create collectible NFTs of iconic dance steps for fans and teaching accreditation.
Discipline: Dance & Choreography (signature step NFTs). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a signature step NFTs work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The signature step NFTs flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA dance-choreochain-badge-10 · Base · ChoreoChain Badge =====
Page: https://arcprompts.lovable.app/ideas/dance-choreochain-badge-10

Build "ChoreoChain Badge" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Award NFT badges for verified choreography skills and professional credentials.
Discipline: Dance & Choreography (certified choreography). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a certified choreography work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The certified choreography flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA dance-dancedna-registry-11 · Base · DanceDNA Registry =====
Page: https://arcprompts.lovable.app/ideas/dance-dancedna-registry-11

Build "DanceDNA Registry" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint NFTs encoding a dancer’s unique style ‘DNA’ for branding and licensing.
Discipline: Dance & Choreography (personal style encoding). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a personal style encoding work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The personal style encoding flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA dance-pulseproof-archives-12 · Base · PulseProof Archives =====
Page: https://arcprompts.lovable.app/ideas/dance-pulseproof-archives-12

Build "PulseProof Archives" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Create immutable NFT records of historical dance footage for rights and preservation.
Discipline: Dance & Choreography (historical dance archives). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a historical dance archives work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The historical dance archives flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA dance-spinmint-marketplace-13 · Base · SpinMint Marketplace =====
Page: https://arcprompts.lovable.app/ideas/dance-spinmint-marketplace-13

Build "SpinMint Marketplace" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Tokenize 360° recorded dance moves as NFTs to share with immersive digital experiences.
Discipline: Dance & Choreography (360 dance moves). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a 360 dance moves work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The 360 dance moves flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA dance-movemark-licensing-14 · Base · MoveMark Licensing =====
Page: https://arcprompts.lovable.app/ideas/dance-movemark-licensing-14

Build "MoveMark Licensing" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
License choreography sequences securely as NFTs to streamline usage tracking and payments.
Discipline: Dance & Choreography (choreography licensing). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a choreography licensing work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The choreography licensing flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA dance-freezeframe-tokens-15 · Base · FreezeFrame Tokens =====
Page: https://arcprompts.lovable.app/ideas/dance-freezeframe-tokens-15

Build "FreezeFrame Tokens" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint NFTs capturing iconic frozen dance frames for fan engagement and merchandising.
Discipline: Dance & Choreography (iconic frozen poses). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a iconic frozen poses work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The iconic frozen poses flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA dance-stepsync-remix-16 · Base · StepSync Remix =====
Page: https://arcprompts.lovable.app/ideas/dance-stepsync-remix-16

Build "StepSync Remix" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint and license remixable dance steps as NFTs to promote collaborative creation.
Discipline: Dance & Choreography (dance step sampling). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a dance step sampling work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The dance step sampling flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA dance-choreocraft-tokens-17 · Base · ChoreoCraft Tokens =====
Page: https://arcprompts.lovable.app/ideas/dance-choreocraft-tokens-17

Build "ChoreoCraft Tokens" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Create and sell NFT-backed custom choreography kits for teachers and studios.
Discipline: Dance & Choreography (custom choreography kits). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a custom choreography kits work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The custom choreography kits flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA dance-dancetrail-provenance-18 · Base · DanceTrail Provenance =====
Page: https://arcprompts.lovable.app/ideas/dance-dancetrail-provenance-18

Build "DanceTrail Provenance" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Record and mint NFT trails of live performances to authenticate originality and authorship.
Discipline: Dance & Choreography (performance recording). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a performance recording work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The performance recording flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA dance-rhythmripple-chain-19 · Base · RhythmRipple Chain =====
Page: https://arcprompts.lovable.app/ideas/dance-rhythmripple-chain-19

Build "RhythmRipple Chain" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Tokenize rhythm sequences as NFTs for secure ownership and licensing in dance shows.
Discipline: Dance & Choreography (beat choreography). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a beat choreography work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The beat choreography flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA dance-movemint-studio-20 · Base · MoveMint Studio =====
Page: https://arcprompts.lovable.app/ideas/dance-movemint-studio-20

Build "MoveMint Studio" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Choreographers mint unique dance moves as NFTs to monetize and protect their creations.
Discipline: Dance & Choreography (original move minting). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a original move minting work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The original move minting flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA dance-posechain-gallery-21 · Base · PoseChain Gallery =====
Page: https://arcprompts.lovable.app/ideas/dance-posechain-gallery-21

Build "PoseChain Gallery" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Create galleries of NFT-verified dance poses to showcase and sell digital art collections.
Discipline: Dance & Choreography (dance pose exhibitions). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a dance pose exhibitions work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The dance pose exhibitions flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA dance-glideproof-tokens-22 · Base · GlideProof Tokens =====
Page: https://arcprompts.lovable.app/ideas/dance-glideproof-tokens-22

Build "GlideProof Tokens" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint NFTs encoding fluidity metrics of dance sequences for analytics and coaching.
Discipline: Dance & Choreography (fluidity measurement). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a fluidity measurement work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The fluidity measurement flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA dance-shadowstep-registry-23 · Base · ShadowStep Registry =====
Page: https://arcprompts.lovable.app/ideas/dance-shadowstep-registry-23

Build "ShadowStep Registry" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Catalog silent or lip-synced dance movements as NFTs for licensing and crediting.
Discipline: Dance & Choreography (silent movement catalog). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a silent movement catalog work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The silent movement catalog flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA dance-leapchain-ledger-24 · Base · LeapChain Ledger =====
Page: https://arcprompts.lovable.app/ideas/dance-leapchain-ledger-24

Build "LeapChain Ledger" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint NFTs of signature leaps to prove originality and enable commercial licensing.
Discipline: Dance & Choreography (leaps and jumps). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a leaps and jumps work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The leaps and jumps flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA music-loop-provenance-0 · Base · Loop Provenance =====
Page: https://arcprompts.lovable.app/ideas/music-loop-provenance-0

Build "Loop Provenance" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Track and verify original creators of music loops and samples to credit and reward authors accurately.
Discipline: Music & Sound Design (sample tracking). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a sample tracking item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The sample tracking flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA music-onchain-remix-rights-1 · Base · Onchain Remix Rights =====
Page: https://arcprompts.lovable.app/ideas/music-onchain-remix-rights-1

Build "Onchain Remix Rights" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Enable transparent licensing and royalty splits for remixed tracks directly on the blockchain.
Discipline: Music & Sound Design (remix licensing). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a remix licensing item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The remix licensing flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA music-collaborative-beat-ledger-2 · Base · Collaborative Beat Ledger =====
Page: https://arcprompts.lovable.app/ideas/music-collaborative-beat-ledger-2

Build "Collaborative Beat Ledger" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Record and timestamp collaborative beat creation sessions with immutable proof of contribution.
Discipline: Music & Sound Design (beat collaboration). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a beat collaboration item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The beat collaboration flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA music-sound-effect-nft-vault-3 · Base · Sound Effect NFT Vault =====
Page: https://arcprompts.lovable.app/ideas/music-sound-effect-nft-vault-3

Build "Sound Effect NFT Vault" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint and trade exclusive sound effects as NFTs ensuring ownership and monetization for creators.
Discipline: Music & Sound Design (sound libraries). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a sound libraries item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The sound libraries flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA music-onchain-sample-swap-4 · Base · Onchain Sample Swap =====
Page: https://arcprompts.lovable.app/ideas/music-onchain-sample-swap-4

Build "Onchain Sample Swap" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Facilitate peer-to-peer swapping of music samples with provable ownership and usage rights.
Discipline: Music & Sound Design (sample exchange). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a sample exchange item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The sample exchange flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA music-live-set-royalty-split-5 · Base · Live Set Royalty Split =====
Page: https://arcprompts.lovable.app/ideas/music-live-set-royalty-split-5

Build "Live Set Royalty Split" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Automatically distribute royalty shares from live streamed performances via smart contracts.
Discipline: Music & Sound Design (live performance). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a live performance item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The live performance flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA music-ai-audio-license-6 · Base · AI Audio License =====
Page: https://arcprompts.lovable.app/ideas/music-ai-audio-license-6

Build "AI Audio License" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Onchain licenses for AI-created audio to prevent misuse and ensure creator credit.
Discipline: Music & Sound Design (AI-generated music). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a AI-generated music item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The AI-generated music flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA music-onchain-music-curriculum-7 · Base · Onchain Music Curriculum =====
Page: https://arcprompts.lovable.app/ideas/music-onchain-music-curriculum-7

Build "Onchain Music Curriculum" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Certify students’ composition and sound design achievements onchain for transparent credentialing.
Discipline: Music & Sound Design (music education). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a music education item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The music education flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA music-tokenized-composer-credits-8 · Base · Tokenized Composer Credits =====
Page: https://arcprompts.lovable.app/ideas/music-tokenized-composer-credits-8

Build "Tokenized Composer Credits" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Issue tokens representing composer credits to ensure fair recognition and revenue sharing.
Discipline: Music & Sound Design (credit attribution). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a credit attribution item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The credit attribution flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA music-sound-asset-crowdfunding-9 · Base · Sound Asset Crowdfunding =====
Page: https://arcprompts.lovable.app/ideas/music-sound-asset-crowdfunding-9

Build "Sound Asset Crowdfunding" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Raise decentralized funding for music and sound projects with onchain milestone payments.
Discipline: Music & Sound Design (music funding). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a music funding item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The music funding flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA music-onchain-synth-presets-10 · Base · Onchain Synth Presets =====
Page: https://arcprompts.lovable.app/ideas/music-onchain-synth-presets-10

Build "Onchain Synth Presets" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Distribute unique synthesizer presets as verifiable NFTs with built-in royalty logic.
Discipline: Music & Sound Design (synth programming). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a synth programming item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The synth programming flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA music-decentralized-jam-sessions-11 · Base · Decentralized Jam Sessions =====
Page: https://arcprompts.lovable.app/ideas/music-decentralized-jam-sessions-11

Build "Decentralized Jam Sessions" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Record and timestamp decentralized jam sessions to prove creative input for all participants.
Discipline: Music & Sound Design (remote collaboration). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a remote collaboration item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The remote collaboration flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA music-interactive-sound-nfts-12 · Base · Interactive Sound NFTs =====
Page: https://arcprompts.lovable.app/ideas/music-interactive-sound-nfts-12

Build "Interactive Sound NFTs" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Create NFTs with interactive sound design that evolves based on user input and onchain data.
Discipline: Music & Sound Design (dynamic audio). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a dynamic audio item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The dynamic audio flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA music-onchain-remix-competitions-13 · Base · Onchain Remix Competitions =====
Page: https://arcprompts.lovable.app/ideas/music-onchain-remix-competitions-13

Build "Onchain Remix Competitions" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Host remix contests with transparent voting and automatic prize payouts on the blockchain.
Discipline: Music & Sound Design (contest management). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a contest management item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The contest management flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA music-sample-chain-marketplace-14 · Base · Sample Chain Marketplace =====
Page: https://arcprompts.lovable.app/ideas/music-sample-chain-marketplace-14

Build "Sample Chain Marketplace" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Create a decentralized marketplace for verified, licensed music samples with automatic royalties.
Discipline: Music & Sound Design (music marketplaces). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a music marketplaces item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The music marketplaces flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA music-onchain-audio-stems-15 · Base · Onchain Audio Stems =====
Page: https://arcprompts.lovable.app/ideas/music-onchain-audio-stems-15

Build "Onchain Audio Stems" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Distribute song stems with immutable licenses and resale royalty tracking onchain.
Discipline: Music & Sound Design (stem distribution). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a stem distribution item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The stem distribution flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA music-blockchain-soundscapes-16 · Base · Blockchain Soundscapes =====
Page: https://arcprompts.lovable.app/ideas/music-blockchain-soundscapes-16

Build "Blockchain Soundscapes" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Share and license unique recorded soundscapes with verified origin and ownership on blockchain.
Discipline: Music & Sound Design (environmental audio). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a environmental audio item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The environmental audio flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA music-decentralized-music-feedback-17 · Base · Decentralized Music Feedback =====
Page: https://arcprompts.lovable.app/ideas/music-decentralized-music-feedback-17

Build "Decentralized Music Feedback" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Collect transparent, timestamped peer reviews for music tracks to build trust and credibility.
Discipline: Music & Sound Design (peer review). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a peer review item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The peer review flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA music-onchain-dj-set-logs-18 · Base · Onchain DJ Set Logs =====
Page: https://arcprompts.lovable.app/ideas/music-onchain-dj-set-logs-18

Build "Onchain DJ Set Logs" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Create immutable records of DJ set tracklists and transitions for copyright and reputation.
Discipline: Music & Sound Design (performance archiving). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a performance archiving item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The performance archiving flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA music-smart-contract-audio-rng-19 · Base · Smart Contract Audio RNG =====
Page: https://arcprompts.lovable.app/ideas/music-smart-contract-audio-rng-19

Build "Smart Contract Audio RNG" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Use onchain randomness to generate unique, verifiable generative music pieces as NFTs.
Discipline: Music & Sound Design (generative music). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a generative music item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The generative music flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA music-token-gated-music-releases-20 · Base · Token-Gated Music Releases =====
Page: https://arcprompts.lovable.app/ideas/music-token-gated-music-releases-20

Build "Token-Gated Music Releases" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Release exclusive music content accessible only to token holders via smart contracts.
Discipline: Music & Sound Design (exclusive content). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a exclusive content item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The exclusive content flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA music-onchain-vocal-processing-21 · Base · Onchain Vocal Processing =====
Page: https://arcprompts.lovable.app/ideas/music-onchain-vocal-processing-21

Build "Onchain Vocal Processing" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Store and verify customizable vocal effect presets and chains onchain for sharing and licensing.
Discipline: Music & Sound Design (vocal effects). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a vocal effects item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The vocal effects flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA music-music-metadata-registry-22 · Base · Music Metadata Registry =====
Page: https://arcprompts.lovable.app/ideas/music-music-metadata-registry-22

Build "Music Metadata Registry" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Create a decentralized registry for verified, searchable music metadata and ownership info.
Discipline: Music & Sound Design (metadata management). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a metadata management item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The metadata management flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA music-smart-contract-sync-licenses-23 · Base · Smart Contract Sync Licenses =====
Page: https://arcprompts.lovable.app/ideas/music-smart-contract-sync-licenses-23

Build "Smart Contract Sync Licenses" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Automate sync rights clearance and royalty splits for film, TV, and ads on the blockchain.
Discipline: Music & Sound Design (sync licensing). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a sync licensing item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The sync licensing flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA music-onchain-audio-watermarking-24 · Base · Onchain Audio Watermarking =====
Page: https://arcprompts.lovable.app/ideas/music-onchain-audio-watermarking-24

Build "Onchain Audio Watermarking" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Embed immutable proof of ownership and usage terms in audio files verified via blockchain.
Discipline: Music & Sound Design (copyright protection). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a copyright protection item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The copyright protection flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA music-loop-provenance-0 · Base · Loop Provenance =====
Page: https://arcprompts.lovable.app/ideas/music-loop-provenance-0

Build "Loop Provenance" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Track and verify origin of audio loops to ensure authenticity for musicians and producers.
Discipline: Music & Sound Design (sample lineage). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a sample lineage sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The sample lineage flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA music-patch-vault-1 · Base · Patch Vault =====
Page: https://arcprompts.lovable.app/ideas/music-patch-vault-1

Build "Patch Vault" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Securely store and share synthesizer presets with verified authenticity and version control.
Discipline: Music & Sound Design (synth preset archiving). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a synth preset archiving sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The synth preset archiving flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA music-score-archive-2 · Base · Score Archive =====
Page: https://arcprompts.lovable.app/ideas/music-score-archive-2

Build "Score Archive" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Permanently archive music scores and compositions with guaranteed timestamped records.
Discipline: Music & Sound Design (composition notation). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a composition notation sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The composition notation flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA music-samplechain-3 · Base · SampleChain =====
Page: https://arcprompts.lovable.app/ideas/music-samplechain-3

Build "SampleChain" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Manage and prove sample license ownership with permanent onchain records for producers.
Discipline: Music & Sound Design (sample licensing). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a sample licensing sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The sample licensing flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA music-mix-history-4 · Base · Mix History =====
Page: https://arcprompts.lovable.app/ideas/music-mix-history-4

Build "Mix History" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Track iterative versions of audio mixes ensuring creators can revert and prove mix lineage.
Discipline: Music & Sound Design (mix versioning). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a mix versioning sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The mix versioning flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA music-soundscape-atlas-5 · Base · Soundscape Atlas =====
Page: https://arcprompts.lovable.app/ideas/music-soundscape-atlas-5

Build "Soundscape Atlas" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Catalog and permanently archive environmental soundscapes for reuse and licensing.
Discipline: Music & Sound Design (field recording). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a field recording sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The field recording flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA music-preset-gallery-6 · Base · Preset Gallery =====
Page: https://arcprompts.lovable.app/ideas/music-preset-gallery-6

Build "Preset Gallery" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Create a decentralized gallery of verified plugin presets with community ratings.
Discipline: Music & Sound Design (plugin preset sharing). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a plugin preset sharing sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The plugin preset sharing flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA music-vinyl-metadata-7 · Base · Vinyl Metadata =====
Page: https://arcprompts.lovable.app/ideas/music-vinyl-metadata-7

Build "Vinyl Metadata" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Digitally archive vinyl metadata linked to physical records for collectors and sellers.
Discipline: Music & Sound Design (record collection). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a record collection sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The record collection flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA music-moodsampler-8 · Base · MoodSampler =====
Page: https://arcprompts.lovable.app/ideas/music-moodsampler-8

Build "MoodSampler" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Attach permanent mood and emotion tags to samples for easy discovery and curation.
Discipline: Music & Sound Design (emotional tagging). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a emotional tagging sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The emotional tagging flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA music-beatledger-9 · Base · BeatLedger =====
Page: https://arcprompts.lovable.app/ideas/music-beatledger-9

Build "BeatLedger" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Record and prove ownership of beats and instrumentals on a decentralized archive.
Discipline: Music & Sound Design (beat ownership). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a beat ownership sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The beat ownership flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA music-synth-patchbook-10 · Base · Synth Patchbook =====
Page: https://arcprompts.lovable.app/ideas/music-synth-patchbook-10

Build "Synth Patchbook" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Create a permanent catalog of unique synth patches for community sharing and licensing.
Discipline: Music & Sound Design (sound design catalog). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a sound design catalog sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The sound design catalog flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA music-remix-rights-11 · Base · Remix Rights =====
Page: https://arcprompts.lovable.app/ideas/music-remix-rights-11

Build "Remix Rights" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Track remix permissions and derivatives with permanent records linked to original works.
Discipline: Music & Sound Design (remix management). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a remix management sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The remix management flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA music-loopswap-12 · Base · LoopSwap =====
Page: https://arcprompts.lovable.app/ideas/music-loopswap-12

Build "LoopSwap" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Decentralized platform for permanent loop exchange with verified content provenance.
Discipline: Music & Sound Design (loop exchange). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a loop exchange sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The loop exchange flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA music-patch-ledger-13 · Base · Patch Ledger =====
Page: https://arcprompts.lovable.app/ideas/music-patch-ledger-13

Build "Patch Ledger" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Record creation and usage history of sound patches to prove originality and licensing.
Discipline: Music & Sound Design (sound patch tracking). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a sound patch tracking sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The sound patch tracking flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA music-composer-collab-14 · Base · Composer Collab =====
Page: https://arcprompts.lovable.app/ideas/music-composer-collab-14

Build "Composer Collab" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Securely share and timestamp collaborative compositions with permanent version control.
Discipline: Music & Sound Design (composition sharing). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a composition sharing sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The composition sharing flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA music-sound-nft-15 · Base · Sound NFT =====
Page: https://arcprompts.lovable.app/ideas/music-sound-nft-15

Build "Sound NFT" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Create permanent and verifiable audio NFTs with linked metadata on decentralized storage.
Discipline: Music & Sound Design (audio collectibles). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a audio collectibles sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The audio collectibles flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA music-samplechain-pro-16 · Base · SampleChain Pro =====
Page: https://arcprompts.lovable.app/ideas/music-samplechain-pro-16

Build "SampleChain Pro" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Professional tool to trace sample origins and licensing history with permanent records.
Discipline: Music & Sound Design (sample provenance). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a sample provenance sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The sample provenance flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA music-liveloop-archive-17 · Base · LiveLoop Archive =====
Page: https://arcprompts.lovable.app/ideas/music-liveloop-archive-17

Build "LiveLoop Archive" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Permanently store live loop sets with detailed metadata for reuse and proof of creation.
Discipline: Music & Sound Design (live set recording). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a live set recording sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The live set recording flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA music-soundpatch-market-18 · Base · SoundPatch Market =====
Page: https://arcprompts.lovable.app/ideas/music-soundpatch-market-18

Build "SoundPatch Market" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Decentralized marketplace for buying and selling sound patches with permanent proof of originality.
Discipline: Music & Sound Design (preset marketplace). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a preset marketplace sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The preset marketplace flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA music-genre-mapper-19 · Base · Genre Mapper =====
Page: https://arcprompts.lovable.app/ideas/music-genre-mapper-19

Build "Genre Mapper" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Attach permanent genre and style metadata to tracks for better discovery and curation.
Discipline: Music & Sound Design (music classification). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a music classification sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The music classification flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA music-audio-blueprint-20 · Base · Audio Blueprint =====
Page: https://arcprompts.lovable.app/ideas/music-audio-blueprint-20

Build "Audio Blueprint" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Archive reusable sound design templates with verified authorship and version tracking.
Discipline: Music & Sound Design (sound design templates). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a sound design templates sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The sound design templates flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA music-loopchain-sync-21 · Base · LoopChain Sync =====
Page: https://arcprompts.lovable.app/ideas/music-loopchain-sync-21

Build "LoopChain Sync" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Synchronize loop edits in real-time with permanent version storage on decentralized archive.
Discipline: Music & Sound Design (collaborative looping). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a collaborative looping sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The collaborative looping flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA music-dynamic-scores-22 · Base · Dynamic Scores =====
Page: https://arcprompts.lovable.app/ideas/music-dynamic-scores-22

Build "Dynamic Scores" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Store interactive music scores with embedded sounds permanently for composers and educators.
Discipline: Music & Sound Design (interactive notation). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a interactive notation sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The interactive notation flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA music-stem-provenance-23 · Base · Stem Provenance =====
Page: https://arcprompts.lovable.app/ideas/music-stem-provenance-23

Build "Stem Provenance" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Track origin and licensing of individual stems with permanent onchain metadata storage.
Discipline: Music & Sound Design (multitrack tracking). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a multitrack tracking sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The multitrack tracking flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA music-gasless-remix-exchange-0 · Base · Gasless Remix Exchange =====
Page: https://arcprompts.lovable.app/ideas/music-gasless-remix-exchange-0

Build "Gasless Remix Exchange" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Collaborate seamlessly on remixes without blockchain fees or sign-up friction.
Discipline: Music & Sound Design (collaborative remixing). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a collaborative remixing action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The collaborative remixing flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA music-onchain-sound-packs-1 · Base · Onchain Sound Packs =====
Page: https://arcprompts.lovable.app/ideas/music-onchain-sound-packs-1

Build "Onchain Sound Packs" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Distribute sound packs with verified authenticity and instant user access via gasless wallets.
Discipline: Music & Sound Design (sample library distribution). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a sample library distribution action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The sample library distribution flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA music-nft-beat-marketplace-2 · Base · NFT Beat Marketplace =====
Page: https://arcprompts.lovable.app/ideas/music-nft-beat-marketplace-2

Build "NFT Beat Marketplace" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Buy and sell beats with onchain provenance and zero gas fee transactions.
Discipline: Music & Sound Design (beat selling). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a beat selling action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The beat selling flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA music-instant-royalty-splits-3 · Base · Instant Royalty Splits =====
Page: https://arcprompts.lovable.app/ideas/music-instant-royalty-splits-3

Build "Instant Royalty Splits" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Automatically split royalties among collaborators with transparent, gasless onchain transactions.
Discipline: Music & Sound Design (music rights management). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a music rights management action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The music rights management flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA music-gas-free-live-sampling-4 · Base · Gas-Free Live Sampling =====
Page: https://arcprompts.lovable.app/ideas/music-gas-free-live-sampling-4

Build "Gas-Free Live Sampling" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Capture and share live samples onchain instantly without blockchain transaction fees.
Discipline: Music & Sound Design (live-set sampling). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a live-set sampling action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The live-set sampling flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA music-social-jam-sessions-5 · Base · Social Jam Sessions =====
Page: https://arcprompts.lovable.app/ideas/music-social-jam-sessions-5

Build "Social Jam Sessions" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Join real-time jam sessions with authenticated users and transparent blockchain session logs.
Discipline: Music & Sound Design (online collaboration). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a online collaboration action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The online collaboration flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA music-curated-sound-trails-6 · Base · Curated Sound Trails =====
Page: https://arcprompts.lovable.app/ideas/music-curated-sound-trails-6

Build "Curated Sound Trails" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Create and share onchain-curated playlists with gasless user interaction and proof of curation.
Discipline: Music & Sound Design (music curation). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a music curation action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The music curation flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA music-authentic-sample-provenance-7 · Base · Authentic Sample Provenance =====
Page: https://arcprompts.lovable.app/ideas/music-authentic-sample-provenance-7

Build "Authentic Sample Provenance" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Verify sample origins onchain with free, user-friendly wallet onboarding to prevent piracy.
Discipline: Music & Sound Design (sample authentication). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a sample authentication action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The sample authentication flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA music-onchain-synth-presets-8 · Base · Onchain Synth Presets =====
Page: https://arcprompts.lovable.app/ideas/music-onchain-synth-presets-8

Build "Onchain Synth Presets" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Distribute and monetize synth presets with gas-free transactions and easy social login.
Discipline: Music & Sound Design (sound design presets). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a sound design presets action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The sound design presets flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA music-gasless-beat-battles-9 · Base · Gasless Beat Battles =====
Page: https://arcprompts.lovable.app/ideas/music-gasless-beat-battles-9

Build "Gasless Beat Battles" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Host onchain beat battles allowing creators to compete and vote without paying blockchain fees.
Discipline: Music & Sound Design (music competitions). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a music competitions action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The music competitions flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA music-collaborative-loop-vault-10 · Base · Collaborative Loop Vault =====
Page: https://arcprompts.lovable.app/ideas/music-collaborative-loop-vault-10

Build "Collaborative Loop Vault" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Securely share and build loop collections with zero gas cost and social wallet access.
Discipline: Music & Sound Design (loop sharing). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a loop sharing action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The loop sharing flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA music-transparent-sample-licensing-11 · Base · Transparent Sample Licensing =====
Page: https://arcprompts.lovable.app/ideas/music-transparent-sample-licensing-11

Build "Transparent Sample Licensing" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
License samples with onchain transparency and gasless user adoption via social login.
Discipline: Music & Sound Design (sample rights). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a sample rights action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The sample rights flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA music-instant-collab-contracts-12 · Base · Instant Collab Contracts =====
Page: https://arcprompts.lovable.app/ideas/music-instant-collab-contracts-12

Build "Instant Collab Contracts" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Create and sign collaboration agreements onchain instantly without gas fees or complex wallet setup.
Discipline: Music & Sound Design (agreement automation). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a agreement automation action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The agreement automation flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA music-gasless-sound-design-nft-13 · Base · Gasless Sound Design NFT =====
Page: https://arcprompts.lovable.app/ideas/music-gasless-sound-design-nft-13

Build "Gasless Sound Design NFT" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint and trade unique sound designs onchain with free wallet sign-ins and sponsored tx.
Discipline: Music & Sound Design (NFT sound assets). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a NFT sound assets action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The NFT sound assets flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA music-onchain-mix-feedback-14 · Base · Onchain Mix Feedback =====
Page: https://arcprompts.lovable.app/ideas/music-onchain-mix-feedback-14

Build "Onchain Mix Feedback" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Receive verified community feedback on mixes with gasless voting and wallet authentication.
Discipline: Music & Sound Design (mix critique). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a mix critique action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The mix critique flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA music-gasless-sample-swap-15 · Base · Gasless Sample Swap =====
Page: https://arcprompts.lovable.app/ideas/music-gasless-sample-swap-15

Build "Gasless Sample Swap" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Swap samples peer-to-peer with instant, free onchain transactions and simple social login.
Discipline: Music & Sound Design (sample exchange). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a sample exchange action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The sample exchange flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA music-live-set-proof-16 · Base · Live Set Proof =====
Page: https://arcprompts.lovable.app/ideas/music-live-set-proof-16

Build "Live Set Proof" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Proof your live performances onchain with zero gas fees and social wallet ease.
Discipline: Music & Sound Design (performance verification). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a performance verification action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The performance verification flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA music-gasless-loop-licensing-17 · Base · Gasless Loop Licensing =====
Page: https://arcprompts.lovable.app/ideas/music-gasless-loop-licensing-17

Build "Gasless Loop Licensing" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
License loops onchain with frictionless onboarding and no blockchain transaction fees.
Discipline: Music & Sound Design (loop rights). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a loop rights action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The loop rights flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA music-social-audio-credits-18 · Base · Social Audio Credits =====
Page: https://arcprompts.lovable.app/ideas/music-social-audio-credits-18

Build "Social Audio Credits" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Tip and credit collaborators instantly with gasless onchain microtransactions via social login.
Discipline: Music & Sound Design (microtransactions). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a microtransactions action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The microtransactions flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA music-gasless-synth-sharing-19 · Base · Gasless Synth Sharing =====
Page: https://arcprompts.lovable.app/ideas/music-gasless-synth-sharing-19

Build "Gasless Synth Sharing" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Share and demo synthesizer presets with gas-free onchain transactions and social wallet integration.
Discipline: Music & Sound Design (preset sharing). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a preset sharing action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The preset sharing flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA music-onchain-audio-stems-20 · Base · Onchain Audio Stems =====
Page: https://arcprompts.lovable.app/ideas/music-onchain-audio-stems-20

Build "Onchain Audio Stems" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Distribute high-quality audio stems with transparent ownership and zero gas fees.
Discipline: Music & Sound Design (stem distribution). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a stem distribution action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The stem distribution flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA music-gasless-sample-challenges-21 · Base · Gasless Sample Challenges =====
Page: https://arcprompts.lovable.app/ideas/music-gasless-sample-challenges-21

Build "Gasless Sample Challenges" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Run onchain sample challenge contests with free user participation and wallet sign-in.
Discipline: Music & Sound Design (creative contests). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a creative contests action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The creative contests flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA music-decentralized-sound-workshops-22 · Base · Decentralized Sound Workshops =====
Page: https://arcprompts.lovable.app/ideas/music-decentralized-sound-workshops-22

Build "Decentralized Sound Workshops" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Host interactive sound design workshops with onchain attendance proofs and no gas fees.
Discipline: Music & Sound Design (music education). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a music education action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The music education flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA music-collaborative-audio-nfts-23 · Base · Collaborative Audio NFTs =====
Page: https://arcprompts.lovable.app/ideas/music-collaborative-audio-nfts-23

Build "Collaborative Audio NFTs" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint multi-creator audio NFTs with transparent ownership and gasless transactions.
Discipline: Music & Sound Design (co-authored NFTs). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a co-authored NFTs action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The co-authored NFTs flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA music-gasless-midi-trading-24 · Base · Gasless MIDI Trading =====
Page: https://arcprompts.lovable.app/ideas/music-gasless-midi-trading-24

Build "Gasless MIDI Trading" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Trade MIDI files onchain instantly with social login and no blockchain fees.
Discipline: Music & Sound Design (MIDI asset exchange). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a MIDI asset exchange action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The MIDI asset exchange flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA music-sample-provenance-vault-0 · Base · Sample Provenance Vault =====
Page: https://arcprompts.lovable.app/ideas/music-sample-provenance-vault-0

Build "Sample Provenance Vault" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Securely mint and verify original samples for trusted reuse and licensing.
Discipline: Music & Sound Design (sample library curation). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a sample library curation work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The sample library curation flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA music-mix-snapshot-ledger-1 · Base · Mix Snapshot Ledger =====
Page: https://arcprompts.lovable.app/ideas/music-mix-snapshot-ledger-1

Build "Mix Snapshot Ledger" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint unique mix versions so producers prove original mixes over time.
Discipline: Music & Sound Design (mix version archiving). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a mix version archiving work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The mix version archiving flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA music-synth-patch-provenance-2 · Base · Synth Patch Provenance =====
Page: https://arcprompts.lovable.app/ideas/music-synth-patch-provenance-2

Build "Synth Patch Provenance" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Create certified original synth presets with owned provenance for resale or sharing.
Discipline: Music & Sound Design (synthesizer preset sharing). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a synthesizer preset sharing work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The synthesizer preset sharing flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA music-sample-remix-rights-3 · Base · Sample Remix Rights =====
Page: https://arcprompts.lovable.app/ideas/music-sample-remix-rights-3

Build "Sample Remix Rights" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint remixable sample NFTs granting verified usage and royalty rights to remixers.
Discipline: Music & Sound Design (remix licensing). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a remix licensing work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The remix licensing flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA music-live-loop-provenance-4 · Base · Live Loop Provenance =====
Page: https://arcprompts.lovable.app/ideas/music-live-loop-provenance-4

Build "Live Loop Provenance" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Capture and mint unique live-loop sessions for verified creative ownership.
Discipline: Music & Sound Design (live performance loops). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a live performance loops work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The live performance loops flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA music-virtual-instrument-tokens-5 · Base · Virtual Instrument Tokens =====
Page: https://arcprompts.lovable.app/ideas/music-virtual-instrument-tokens-5

Build "Virtual Instrument Tokens" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint exclusive sample pack NFTs with creator ownership and usage proofs.
Discipline: Music & Sound Design (instrument sample packs). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a instrument sample packs work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The instrument sample packs flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA music-sound-effect-provenance-6 · Base · Sound Effect Provenance =====
Page: https://arcprompts.lovable.app/ideas/music-sound-effect-provenance-6

Build "Sound Effect Provenance" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Identify and authenticate original sound effect creators with minting onchain tokens.
Discipline: Music & Sound Design (sound effect libraries). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a sound effect libraries work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The sound effect libraries flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA music-composer-cue-tokens-7 · Base · Composer Cue Tokens =====
Page: https://arcprompts.lovable.app/ideas/music-composer-cue-tokens-7

Build "Composer Cue Tokens" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint original music cue NFTs to prove composer ownership and license rights.
Discipline: Music & Sound Design (media scoring segments). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a media scoring segments work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The media scoring segments flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA music-collaborative-track-tokens-8 · Base · Collaborative Track Tokens =====
Page: https://arcprompts.lovable.app/ideas/music-collaborative-track-tokens-8

Build "Collaborative Track Tokens" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Create NFTs representing joint music projects, tracking all contributors’ rights.
Discipline: Music & Sound Design (co-creation tracking). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a co-creation tracking work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The co-creation tracking flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA music-mastering-provenance-tags-9 · Base · Mastering Provenance Tags =====
Page: https://arcprompts.lovable.app/ideas/music-mastering-provenance-tags-9

Build "Mastering Provenance Tags" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint verifiable NFTs for mastered tracks to certify mastering sources and dates.
Discipline: Music & Sound Design (audio mastering records). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a audio mastering records work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The audio mastering records flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA music-remix-chain-registry-10 · Base · Remix Chain Registry =====
Page: https://arcprompts.lovable.app/ideas/music-remix-chain-registry-10

Build "Remix Chain Registry" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Trace remix origins onchain by minting NFT tokens for each remix iteration.
Discipline: Music & Sound Design (remix lineage tracking). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a remix lineage tracking work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The remix lineage tracking flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA music-songwriting-drafts-mint-11 · Base · Songwriting Drafts Mint =====
Page: https://arcprompts.lovable.app/ideas/music-songwriting-drafts-mint-11

Build "Songwriting Drafts Mint" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint NFTs for songwriting drafts to prove original lyric authorship and evolution.
Discipline: Music & Sound Design (lyric version control). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a lyric version control work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The lyric version control flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA music-field-recording-mint-12 · Base · Field Recording Mint =====
Page: https://arcprompts.lovable.app/ideas/music-field-recording-mint-12

Build "Field Recording Mint" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Ownership minting for authentic field recordings archived with verifiable IPFS CIDs.
Discipline: Music & Sound Design (ambient sound archives). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a ambient sound archives work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The ambient sound archives flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA music-sound-design-presets-13 · Base · Sound Design Presets =====
Page: https://arcprompts.lovable.app/ideas/music-sound-design-presets-13

Build "Sound Design Presets" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint and trade unique sound design effect presets with creator provenance.
Discipline: Music & Sound Design (fx preset marketplaces). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a fx preset marketplaces work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The fx preset marketplaces flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA music-album-art-audio-tokens-14 · Base · Album Art Audio Tokens =====
Page: https://arcprompts.lovable.app/ideas/music-album-art-audio-tokens-14

Build "Album Art Audio Tokens" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Combine album art and music provenance by minting unified NFT tokens.
Discipline: Music & Sound Design (integrated art & sound). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a integrated art & sound work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The integrated art & sound flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA music-music-education-tokens-15 · Base · Music Education Tokens =====
Page: https://arcprompts.lovable.app/ideas/music-music-education-tokens-15

Build "Music Education Tokens" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint unique verified music tutorial NFTs proving instructor originality.
Discipline: Music & Sound Design (tutorial authenticity). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a tutorial authenticity work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The tutorial authenticity flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA music-sound-asset-licensing-16 · Base · Sound Asset Licensing =====
Page: https://arcprompts.lovable.app/ideas/music-sound-asset-licensing-16

Build "Sound Asset Licensing" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Streamline sound asset licensing with minting provable NFT ownership tokens.
Discipline: Music & Sound Design (asset marketplace). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a asset marketplace work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The asset marketplace flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA music-genre-evolution-tokens-17 · Base · Genre Evolution Tokens =====
Page: https://arcprompts.lovable.app/ideas/music-genre-evolution-tokens-17

Build "Genre Evolution Tokens" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint NFTs tagging tracks by genre and evolutionary lineage onchain.
Discipline: Music & Sound Design (music style tracking). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a music style tracking work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The music style tracking flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA music-interactive-audio-nfts-18 · Base · Interactive Audio NFTs =====
Page: https://arcprompts.lovable.app/ideas/music-interactive-audio-nfts-18

Build "Interactive Audio NFTs" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint interactive music NFTs with provable ownership and modifiable IPFS content.
Discipline: Music & Sound Design (dynamic sound compositions). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a dynamic sound compositions work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The dynamic sound compositions flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA music-dj-set-provenance-19 · Base · DJ Set Provenance =====
Page: https://arcprompts.lovable.app/ideas/music-dj-set-provenance-19

Build "DJ Set Provenance" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Create certified NFTs of live DJ sets proving originality and performance dates.
Discipline: Music & Sound Design (live set archiving). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a live set archiving work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The live set archiving flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA music-voice-sample-tokens-20 · Base · Voice Sample Tokens =====
Page: https://arcprompts.lovable.app/ideas/music-voice-sample-tokens-20

Build "Voice Sample Tokens" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint NFTs certifying original vocal samples for reuse and licensing.
Discipline: Music & Sound Design (vocal sample authentication). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a vocal sample authentication work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The vocal sample authentication flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA music-podcast-sound-mint-21 · Base · Podcast Sound Mint =====
Page: https://arcprompts.lovable.app/ideas/music-podcast-sound-mint-21

Build "Podcast Sound Mint" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint provenance NFTs for original podcast episodes guaranteeing ownership.
Discipline: Music & Sound Design (podcast audio authenticity). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a podcast audio authenticity work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The podcast audio authenticity flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA music-film-score-provenance-22 · Base · Film Score Provenance =====
Page: https://arcprompts.lovable.app/ideas/music-film-score-provenance-22

Build "Film Score Provenance" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Certify original film scores by minting provenance NFTs tied to IPFS CIDs.
Discipline: Music & Sound Design (cinematic composition). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a cinematic composition work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The cinematic composition flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA music-ambient-track-tokens-23 · Base · Ambient Track Tokens =====
Page: https://arcprompts.lovable.app/ideas/music-ambient-track-tokens-23

Build "Ambient Track Tokens" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint NFTs for ambient compositions verifying original soundscapes.
Discipline: Music & Sound Design (ambient music archives). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a ambient music archives work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The ambient music archives flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA music-instrument-sample-provenance-24 · Base · Instrument Sample Provenance =====
Page: https://arcprompts.lovable.app/ideas/music-instrument-sample-provenance-24

Build "Instrument Sample Provenance" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Create NFTs proving ownership of original instrument sample recordings.
Discipline: Music & Sound Design (instrumental sample rights). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a instrumental sample rights work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The instrumental sample rights flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA visual-art-provenance-palette-0 · Base · Provenance Palette =====
Page: https://arcprompts.lovable.app/ideas/visual-art-provenance-palette-0

Build "Provenance Palette" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Securely track and prove the ownership lineage of paintings with tamper-proof blockchain records.
Discipline: Visual Art (art ownership tracking). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a art ownership tracking item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The art ownership tracking flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA visual-art-generative-mint-studio-1 · Base · Generative Mint Studio =====
Page: https://arcprompts.lovable.app/ideas/visual-art-generative-mint-studio-1

Build "Generative Mint Studio" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Artists can mint unique generative art pieces directly onto Ethereum Sepolia with automated smart contracts.
Discipline: Visual Art (generative art minting). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a generative art minting item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The generative art minting flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA visual-art-exhibit-chain-ledger-2 · Base · Exhibit Chain Ledger =====
Page: https://arcprompts.lovable.app/ideas/visual-art-exhibit-chain-ledger-2

Build "Exhibit Chain Ledger" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Record every artwork's exhibition history securely and transparently onchain for galleries and collectors.
Discipline: Visual Art (gallery exhibition tracking). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a gallery exhibition tracking item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The gallery exhibition tracking flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA visual-art-colorcode-certifier-3 · Base · ColorCode Certifier =====
Page: https://arcprompts.lovable.app/ideas/visual-art-colorcode-certifier-3

Build "ColorCode Certifier" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Certify and verify exact color compositions of artworks using blockchain color code hashes.
Discipline: Visual Art (color authenticity validation). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a color authenticity validation item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The color authenticity validation flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA visual-art-auction-trust-chain-4 · Base · Auction Trust Chain =====
Page: https://arcprompts.lovable.app/ideas/visual-art-auction-trust-chain-4

Build "Auction Trust Chain" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Enable transparent, verifiable auction processes and bids for visual art onchain.
Discipline: Visual Art (art auction transparency). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a art auction transparency item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The art auction transparency flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA visual-art-brushstroke-timestamp-5 · Base · Brushstroke Timestamp =====
Page: https://arcprompts.lovable.app/ideas/visual-art-brushstroke-timestamp-5

Build "Brushstroke Timestamp" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Document and timestamp artists’ brushstroke progress live onchain for proof of creation.
Discipline: Visual Art (creative process timestamping). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a creative process timestamping item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The creative process timestamping flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA visual-art-licensing-ledger-6 · Base · Licensing Ledger =====
Page: https://arcprompts.lovable.app/ideas/visual-art-licensing-ledger-6

Build "Licensing Ledger" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Manage and enforce artwork licensing rights transparently with blockchain smart contracts.
Discipline: Visual Art (artwork license management). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a artwork license management item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The artwork license management flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA visual-art-interactive-canvas-dao-7 · Base · Interactive Canvas DAO =====
Page: https://arcprompts.lovable.app/ideas/visual-art-interactive-canvas-dao-7

Build "Interactive Canvas DAO" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Enable collective decision-making on collaborative visual art projects via decentralized onchain voting.
Discipline: Visual Art (collaborative art governance). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a collaborative art governance item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The collaborative art governance flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA visual-art-art-swap-protocol-8 · Base · Art Swap Protocol =====
Page: https://arcprompts.lovable.app/ideas/visual-art-art-swap-protocol-8

Build "Art Swap Protocol" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Create a trustless platform for artists and collectors to swap artworks instantly onchain.
Discipline: Visual Art (peer-to-peer art exchange). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a peer-to-peer art exchange item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The peer-to-peer art exchange flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA visual-art-edition-tracker-9 · Base · Edition Tracker =====
Page: https://arcprompts.lovable.app/ideas/visual-art-edition-tracker-9

Build "Edition Tracker" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Track edition numbers and print runs of limited artworks securely and transparently onchain.
Discipline: Visual Art (limited print tracking). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a limited print tracking item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The limited print tracking flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA visual-art-art-commission-chain-10 · Base · Art Commission Chain =====
Page: https://arcprompts.lovable.app/ideas/visual-art-art-commission-chain-10

Build "Art Commission Chain" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Streamline and secure commission contracts and payments between artists and patrons using smart contracts.
Discipline: Visual Art (commission workflow management). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a commission workflow management item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The commission workflow management flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA visual-art-dynamic-frame-nfts-11 · Base · Dynamic Frame NFTs =====
Page: https://arcprompts.lovable.app/ideas/visual-art-dynamic-frame-nfts-11

Build "Dynamic Frame NFTs" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Create NFTs that change frames or borders based on onchain conditions or events.
Discipline: Visual Art (programmable artwork framing). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a programmable artwork framing item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The programmable artwork framing flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA visual-art-gallery-access-token-12 · Base · Gallery Access Token =====
Page: https://arcprompts.lovable.app/ideas/visual-art-gallery-access-token-12

Build "Gallery Access Token" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Issue access tokens for exclusive gallery events and exhibitions secured on blockchain.
Discipline: Visual Art (event admission tokens). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a event admission tokens item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The event admission tokens flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA visual-art-art-critique-chain-13 · Base · Art Critique Chain =====
Page: https://arcprompts.lovable.app/ideas/visual-art-art-critique-chain-13

Build "Art Critique Chain" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Record artist peer critiques and feedback permanently and transparently onchain.
Discipline: Visual Art (peer review logging). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a peer review logging item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The peer review logging flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA visual-art-signature-stamp-14 · Base · Signature Stamp =====
Page: https://arcprompts.lovable.app/ideas/visual-art-signature-stamp-14

Build "Signature Stamp" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Cryptographically verify artist signatures on digital and physical artworks using blockchain stamps.
Discipline: Visual Art (artist signature authentication). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a artist signature authentication item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The artist signature authentication flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA visual-art-interactive-auction-game-15 · Base · Interactive Auction Game =====
Page: https://arcprompts.lovable.app/ideas/visual-art-interactive-auction-game-15

Build "Interactive Auction Game" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Turn art auctions into engaging games with transparent rules enforced by onchain smart contracts.
Discipline: Visual Art (gamified art auctions). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a gamified art auctions item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The gamified art auctions flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA visual-art-material-usage-ledger-16 · Base · Material Usage Ledger =====
Page: https://arcprompts.lovable.app/ideas/visual-art-material-usage-ledger-16

Build "Material Usage Ledger" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Track and verify the ethical sourcing and usage of materials in visual artworks onchain.
Discipline: Visual Art (supply chain transparency). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a supply chain transparency item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The supply chain transparency flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA visual-art-visual-royalties-manager-17 · Base · Visual Royalties Manager =====
Page: https://arcprompts.lovable.app/ideas/visual-art-visual-royalties-manager-17

Build "Visual Royalties Manager" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Automate royalty payments to artists via smart contracts every time artwork changes hands.
Discipline: Visual Art (artist royalty automation). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a artist royalty automation item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The artist royalty automation flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA visual-art-moodboard-dao-18 · Base · MoodBoard DAO =====
Page: https://arcprompts.lovable.app/ideas/visual-art-moodboard-dao-18

Build "MoodBoard DAO" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Artists collaboratively curate and govern mood boards for projects using decentralized governance.
Discipline: Visual Art (collective inspiration curation). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a collective inspiration curation item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The collective inspiration curation flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA visual-art-sketch-snapshot-chain-19 · Base · Sketch Snapshot Chain =====
Page: https://arcprompts.lovable.app/ideas/visual-art-sketch-snapshot-chain-19

Build "Sketch Snapshot Chain" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Instantly archive and timestamp digital sketches onchain for secure creative journaling.
Discipline: Visual Art (digital sketch archiving). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a digital sketch archiving item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The digital sketch archiving flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA visual-art-canvas-rental-token-20 · Base · Canvas Rental Token =====
Page: https://arcprompts.lovable.app/ideas/visual-art-canvas-rental-token-20

Build "Canvas Rental Token" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Tokenize and manage temporary rental of studio or gallery spaces for artists seamlessly onchain.
Discipline: Visual Art (art space access). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a art space access item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The art space access flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA visual-art-nft-curation-index-21 · Base · NFT Curation Index =====
Page: https://arcprompts.lovable.app/ideas/visual-art-nft-curation-index-21

Build "NFT Curation Index" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Create and manage curated NFT visual art collections with transparent onchain voting and tracking.
Discipline: Visual Art (curated NFT collections). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a curated NFT collections item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The curated NFT collections flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA visual-art-brushstroke-dao-vault-22 · Base · Brushstroke DAO Vault =====
Page: https://arcprompts.lovable.app/ideas/visual-art-brushstroke-dao-vault-22

Build "Brushstroke DAO Vault" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pool resources in decentralized vaults to fund promising visual art projects transparently.
Discipline: Visual Art (collective art funding). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a collective art funding item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The collective art funding flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA visual-art-art-swap-escrow-23 · Base · Art Swap Escrow =====
Page: https://arcprompts.lovable.app/ideas/visual-art-art-swap-escrow-23

Build "Art Swap Escrow" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Allow artists and collectors to trade artworks using blockchain escrow ensuring transaction safety.
Discipline: Visual Art (secure art trades). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a secure art trades item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The secure art trades flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA visual-art-visual-art-rewards-24 · Base · Visual Art Rewards =====
Page: https://arcprompts.lovable.app/ideas/visual-art-visual-art-rewards-24

Build "Visual Art Rewards" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Reward artists and illustrators for community engagement or milestones via onchain token incentives.
Discipline: Visual Art (artist incentivization). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a artist incentivization item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The artist incentivization flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA visual-art-permacolor-archive-0 · Base · PermaColor Archive =====
Page: https://arcprompts.lovable.app/ideas/visual-art-permacolor-archive-0

Build "PermaColor Archive" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Secure and share your unique color palettes as permanent IPFS references.
Discipline: Visual Art (color palette curation). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a color palette curation sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The color palette curation flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA visual-art-generative-art-vault-1 · Base · Generative Art Vault =====
Page: https://arcprompts.lovable.app/ideas/visual-art-generative-art-vault-1

Build "Generative Art Vault" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin generative art scripts and outputs permanently to preserve creative provenance.
Discipline: Visual Art (algorithmic artwork storage). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a algorithmic artwork storage sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The algorithmic artwork storage flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA visual-art-gallery-manifest-hub-2 · Base · Gallery Manifest Hub =====
Page: https://arcprompts.lovable.app/ideas/visual-art-gallery-manifest-hub-2

Build "Gallery Manifest Hub" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Create and pin permanent digital manifests for art gallery exhibitions with immutable records.
Discipline: Visual Art (exhibition cataloging). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a exhibition cataloging sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The exhibition cataloging flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA visual-art-illustrator-portfolio-lock-3 · Base · Illustrator Portfolio Lock =====
Page: https://arcprompts.lovable.app/ideas/visual-art-illustrator-portfolio-lock-3

Build "Illustrator Portfolio Lock" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Permanently store and share your illustrator portfolios with verifiable IPFS links.
Discipline: Visual Art (portfolio archiving). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a portfolio archiving sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The portfolio archiving flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA visual-art-digital-canvas-ledger-4 · Base · Digital Canvas Ledger =====
Page: https://arcprompts.lovable.app/ideas/visual-art-digital-canvas-ledger-4

Build "Digital Canvas Ledger" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Record and pin painted artwork metadata to IPFS for permanent, tamper-proof provenance.
Discipline: Visual Art (painting provenance tracking). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a painting provenance tracking sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The painting provenance tracking flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA visual-art-nft-manifest-generator-5 · Base · NFT Manifest Generator =====
Page: https://arcprompts.lovable.app/ideas/visual-art-nft-manifest-generator-5

Build "NFT Manifest Generator" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Bundle images and metadata into permanent IPFS manifests to guarantee NFT authenticity.
Discipline: Visual Art (digital asset packaging). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a digital asset packaging sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The digital asset packaging flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA visual-art-interactive-art-pinning-6 · Base · Interactive Art Pinning =====
Page: https://arcprompts.lovable.app/ideas/visual-art-interactive-art-pinning-6

Build "Interactive Art Pinning" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin interactive art assets as JSON and media files, preserving experience forever on IPFS.
Discipline: Visual Art (multimedia art preservation). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a multimedia art preservation sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The multimedia art preservation flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA visual-art-exhibit-provenance-chain-7 · Base · Exhibit Provenance Chain =====
Page: https://arcprompts.lovable.app/ideas/visual-art-exhibit-provenance-chain-7

Build "Exhibit Provenance Chain" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin exhibit documents and artwork proofs to guarantee authenticity for global exhibitions.
Discipline: Visual Art (art exposition verification). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a art exposition verification sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The art exposition verification flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA visual-art-painter-s-time-capsule-8 · Base · Painter’s Time Capsule =====
Page: https://arcprompts.lovable.app/ideas/visual-art-painter-s-time-capsule-8

Build "Painter’s Time Capsule" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Permanently archive each painting stage as images and notes pinned immutably on IPFS.
Discipline: Visual Art (artistic process documentation). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a artistic process documentation sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The artistic process documentation flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA visual-art-visual-art-supply-chain-9 · Base · Visual Art Supply Chain =====
Page: https://arcprompts.lovable.app/ideas/visual-art-visual-art-supply-chain-9

Build "Visual Art Supply Chain" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin supplier certificates and provenance of materials to IPFS for buyer transparency.
Discipline: Visual Art (art materials tracking). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a art materials tracking sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The art materials tracking flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA visual-art-auto-manifest-builder-10 · Base · Auto-Manifest Builder =====
Page: https://arcprompts.lovable.app/ideas/visual-art-auto-manifest-builder-10

Build "Auto-Manifest Builder" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Automatically generate and pin complete IPFS manifests for artists’ works with minimal effort.
Discipline: Visual Art (metadata automation). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a metadata automation sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The metadata automation flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA visual-art-collaborative-art-archive-11 · Base · Collaborative Art Archive =====
Page: https://arcprompts.lovable.app/ideas/visual-art-collaborative-art-archive-11

Build "Collaborative Art Archive" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin shared artworks and process files to IPFS for permanent collaborative history storage.
Discipline: Visual Art (group project documentation). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a group project documentation sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The group project documentation flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA visual-art-style-transfer-keeper-12 · Base · Style Transfer Keeper =====
Page: https://arcprompts.lovable.app/ideas/visual-art-style-transfer-keeper-12

Build "Style Transfer Keeper" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin AI-generated style files and outputs permanently to safeguard unique artistic styles.
Discipline: Visual Art (AI style preservation). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a AI style preservation sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The AI style preservation flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA visual-art-art-fair-digital-catalog-13 · Base · Art Fair Digital Catalog =====
Page: https://arcprompts.lovable.app/ideas/visual-art-art-fair-digital-catalog-13

Build "Art Fair Digital Catalog" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Create and pin permanent digital catalogs for art fairs accessible globally.
Discipline: Visual Art (event art listings). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a event art listings sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The event art listings flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA visual-art-generative-token-gallery-14 · Base · Generative Token Gallery =====
Page: https://arcprompts.lovable.app/ideas/visual-art-generative-token-gallery-14

Build "Generative Token Gallery" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin generative art manifests and images for permanent token-backed gallery display.
Discipline: Visual Art (tokenized generative art). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a tokenized generative art sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The tokenized generative art flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA visual-art-illustration-rights-ledger-15 · Base · Illustration Rights Ledger =====
Page: https://arcprompts.lovable.app/ideas/visual-art-illustration-rights-ledger-15

Build "Illustration Rights Ledger" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin illustration licenses and usage terms permanently for transparent rights management.
Discipline: Visual Art (digital rights management). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a digital rights management sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The digital rights management flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA visual-art-augmented-art-archive-16 · Base · Augmented Art Archive =====
Page: https://arcprompts.lovable.app/ideas/visual-art-augmented-art-archive-16

Build "Augmented Art Archive" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin AR textures, markers, and metadata permanently to IPFS for reliable augmented experiences.
Discipline: Visual Art (AR art content storage). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a AR art content storage sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The AR art content storage flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA visual-art-permanent-sketchbook-hub-17 · Base · Permanent Sketchbook Hub =====
Page: https://arcprompts.lovable.app/ideas/visual-art-permanent-sketchbook-hub-17

Build "Permanent Sketchbook Hub" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin your sketchbook pages as immutable IPFS entries to build a lifelong visual diary.
Discipline: Visual Art (digital sketch archiving). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a digital sketch archiving sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The digital sketch archiving flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA visual-art-visual-storyboard-chain-18 · Base · Visual Storyboard Chain =====
Page: https://arcprompts.lovable.app/ideas/visual-art-visual-storyboard-chain-18

Build "Visual Storyboard Chain" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin storyboards and frame metadata permanently for narrative visual art projects.
Discipline: Visual Art (narrative art sequencing). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a narrative art sequencing sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The narrative art sequencing flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA visual-art-curator-s-immutable-log-19 · Base · Curator’s Immutable Log =====
Page: https://arcprompts.lovable.app/ideas/visual-art-curator-s-immutable-log-19

Build "Curator’s Immutable Log" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin curator notes, selections, and art metadata immutably to IPFS ensuring exhibition integrity.
Discipline: Visual Art (art exhibition curation). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a art exhibition curation sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The art exhibition curation flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA visual-art-visual-remix-repository-20 · Base · Visual Remix Repository =====
Page: https://arcprompts.lovable.app/ideas/visual-art-visual-remix-repository-20

Build "Visual Remix Repository" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin remixed artworks and source attribution information permanently for remix transparency.
Discipline: Visual Art (art remix documentation). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a art remix documentation sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The art remix documentation flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA visual-art-unique-print-provenance-21 · Base · Unique Print Provenance =====
Page: https://arcprompts.lovable.app/ideas/visual-art-unique-print-provenance-21

Build "Unique Print Provenance" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin limited print metadata and certificates immutably to prove authenticity for collectors.
Discipline: Visual Art (limited edition prints). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a limited edition prints sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The limited edition prints flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA visual-art-artistic-collaboration-chain-22 · Base · Artistic Collaboration Chain =====
Page: https://arcprompts.lovable.app/ideas/visual-art-artistic-collaboration-chain-22

Build "Artistic Collaboration Chain" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin and permanently store co-created artworks and contribution metadata for fair crediting.
Discipline: Visual Art (joint creation records). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a joint creation records sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The joint creation records flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA visual-art-visual-rights-archive-23 · Base · Visual Rights Archive =====
Page: https://arcprompts.lovable.app/ideas/visual-art-visual-rights-archive-23

Build "Visual Rights Archive" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin copyright registration data and proofs permanently for artists’ legal protection.
Discipline: Visual Art (copyright preservation). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a copyright preservation sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The copyright preservation flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA visual-art-dynamic-exhibit-snapshot-24 · Base · Dynamic Exhibit Snapshot =====
Page: https://arcprompts.lovable.app/ideas/visual-art-dynamic-exhibit-snapshot-24

Build "Dynamic Exhibit Snapshot" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin snapshots of changing exhibitions and arrangements permanently for historical records.
Discipline: Visual Art (exhibit state recording). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a exhibit state recording sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The exhibit state recording flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA visual-art-canvas-collaborate-0 · Base · Canvas Collaborate =====
Page: https://arcprompts.lovable.app/ideas/visual-art-canvas-collaborate-0

Build "Canvas Collaborate" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Enable painters to co-create artworks with seamless onchain identity and gasless contributions.
Discipline: Visual Art (collaborative painting). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a collaborative painting action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The collaborative painting flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA visual-art-illustrator-guild-1 · Base · Illustrator Guild =====
Page: https://arcprompts.lovable.app/ideas/visual-art-illustrator-guild-1

Build "Illustrator Guild" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Create a hosted network for illustrators to share, sell, and verify work with easy login and zero gas fees.
Discipline: Visual Art (illustrator community). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a illustrator community action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The illustrator community flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA visual-art-generative-canvas-2 · Base · Generative Canvas =====
Page: https://arcprompts.lovable.app/ideas/visual-art-generative-canvas-2

Build "Generative Canvas" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Let generative artists deploy and monetize code-driven art with instant gasless onboarding and transactions.
Discipline: Visual Art (generative art). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a generative art action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The generative art flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA visual-art-gallery-ledger-3 · Base · Gallery Ledger =====
Page: https://arcprompts.lovable.app/ideas/visual-art-gallery-ledger-3

Build "Gallery Ledger" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Provide gallerists with gasless, onchain tools to prove artwork provenance and authenticity effortlessly.
Discipline: Visual Art (art provenance tracking). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a art provenance tracking action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The art provenance tracking flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA visual-art-palette-swap-4 · Base · Palette Swap =====
Page: https://arcprompts.lovable.app/ideas/visual-art-palette-swap-4

Build "Palette Swap" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Allow painters and illustrators to exchange and license color palettes with transparent, gasless transactions.
Discipline: Visual Art (color exchange). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a color exchange action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The color exchange flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA visual-art-sketchstream-5 · Base · SketchStream =====
Page: https://arcprompts.lovable.app/ideas/visual-art-sketchstream-5

Build "SketchStream" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Stream live sketches with integrated onchain tips and gasless wallet logins for artist-audience engagement.
Discipline: Visual Art (live drawing streams). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a live drawing streams action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The live drawing streams flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA visual-art-nft-splitter-6 · Base · NFT Splitter =====
Page: https://arcprompts.lovable.app/ideas/visual-art-nft-splitter-6

Build "NFT Splitter" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Enable painters and collectors to split artwork ownership onchain with easy social login and no gas fees.
Discipline: Visual Art (fractional art ownership). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a fractional art ownership action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The fractional art ownership flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA visual-art-artswap-social-7 · Base · ArtSwap Social =====
Page: https://arcprompts.lovable.app/ideas/visual-art-artswap-social-7

Build "ArtSwap Social" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Build a social marketplace for illustrators to swap artworks and services without gas concerns.
Discipline: Visual Art (art barter communities). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a art barter communities action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The art barter communities flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA visual-art-sketchvault-8 · Base · SketchVault =====
Page: https://arcprompts.lovable.app/ideas/visual-art-sketchvault-8

Build "SketchVault" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Offer painters a gasless, onchain-secured vault for storing and sharing preliminary sketches with social login.
Discipline: Visual Art (secure sketch storage). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a secure sketch storage action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The secure sketch storage flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA visual-art-brushstroke-rights-9 · Base · Brushstroke Rights =====
Page: https://arcprompts.lovable.app/ideas/visual-art-brushstroke-rights-9

Build "Brushstroke Rights" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Help illustrators manage and transfer licenses onchain with simple Google sign-in and zero gas.
Discipline: Visual Art (digital rights management). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a digital rights management action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The digital rights management flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA visual-art-artchain-auctions-10 · Base · ArtChain Auctions =====
Page: https://arcprompts.lovable.app/ideas/visual-art-artchain-auctions-10

Build "ArtChain Auctions" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Create gasless onchain auctions for visual artists with fast wallet onboarding and sponsored bids.
Discipline: Visual Art (auction facilitation). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a auction facilitation action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The auction facilitation flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA visual-art-framefi-marketplace-11 · Base · FrameFi Marketplace =====
Page: https://arcprompts.lovable.app/ideas/visual-art-framefi-marketplace-11

Build "FrameFi Marketplace" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Enable illustrators to sell artworks with embedded gasless framing add-ons and easy wallet login.
Discipline: Visual Art (digital framing services). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a digital framing services action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The digital framing services flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA visual-art-mural-mesh-12 · Base · Mural Mesh =====
Page: https://arcprompts.lovable.app/ideas/visual-art-mural-mesh-12

Build "Mural Mesh" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Coordinate large-scale public murals with painters via gasless onchain collaboration and social login.
Discipline: Visual Art (public mural collaboration). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a public mural collaboration action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The public mural collaboration flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA visual-art-colorstory-13 · Base · ColorStory =====
Page: https://arcprompts.lovable.app/ideas/visual-art-colorstory-13

Build "ColorStory" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Illustrators share evolving color-based stories secured onchain with gasless updates and Google sign-in.
Discipline: Visual Art (color narrative art). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a color narrative art action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The color narrative art flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA visual-art-token-tapestry-14 · Base · Token Tapestry =====
Page: https://arcprompts.lovable.app/ideas/visual-art-token-tapestry-14

Build "Token Tapestry" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Artists tokenize and sell unique textile patterns with gasless wallet integration and sponsored transactions.
Discipline: Visual Art (textile pattern art). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a textile pattern art action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The textile pattern art flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA visual-art-gallery-ghost-15 · Base · Gallery Ghost =====
Page: https://arcprompts.lovable.app/ideas/visual-art-gallery-ghost-15

Build "Gallery Ghost" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Gallerists create virtual galleries with gasless onchain ticketing and Google-based wallet onboarding.
Discipline: Visual Art (virtual gallery hosting). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a virtual gallery hosting action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The virtual gallery hosting flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA visual-art-brushbot-16 · Base · BrushBot =====
Page: https://arcprompts.lovable.app/ideas/visual-art-brushbot-16

Build "BrushBot" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Integrate AI painting tools powered by gasless onchain user verification and transactions.
Discipline: Visual Art (AI-assisted painting). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a AI-assisted painting action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The AI-assisted painting flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA visual-art-sketchset-swap-17 · Base · SketchSet Swap =====
Page: https://arcprompts.lovable.app/ideas/visual-art-sketchset-swap-17

Build "SketchSet Swap" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Illustrators trade and license brush presets with zero gas fees and easy Google sign-in wallets.
Discipline: Visual Art (brush preset exchange). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a brush preset exchange action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The brush preset exchange flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA visual-art-artchain-critique-18 · Base · ArtChain Critique =====
Page: https://arcprompts.lovable.app/ideas/visual-art-artchain-critique-18

Build "ArtChain Critique" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Painters share work for peer feedback with onchain reputation and gasless login/transactions.
Discipline: Visual Art (peer review platform). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a peer review platform action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The peer review platform flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA visual-art-illustrate-impact-19 · Base · Illustrate Impact =====
Page: https://arcprompts.lovable.app/ideas/visual-art-illustrate-impact-19

Build "Illustrate Impact" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Facilitate gasless donations and sponsorships for illustrators supporting social causes via easy login.
Discipline: Visual Art (art philanthropy). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a art philanthropy action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The art philanthropy flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA visual-art-colorchain-auctions-20 · Base · Colorchain Auctions =====
Page: https://arcprompts.lovable.app/ideas/visual-art-colorchain-auctions-20

Build "Colorchain Auctions" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Host auctions of color-driven artworks with gasless bidding and quick wallet onboarding.
Discipline: Visual Art (color-themed art auctions). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a color-themed art auctions action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The color-themed art auctions flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA visual-art-illustrator-ink-21 · Base · Illustrator Ink =====
Page: https://arcprompts.lovable.app/ideas/visual-art-illustrator-ink-21

Build "Illustrator Ink" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Support ink artists selling limited editions with gasless minting and sponsored transaction flows.
Discipline: Visual Art (digital ink art). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a digital ink art action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The digital ink art flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA visual-art-generative-gallery-22 · Base · Generative Gallery =====
Page: https://arcprompts.lovable.app/ideas/visual-art-generative-gallery-22

Build "Generative Gallery" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Curate generative art exhibits featuring gasless ticketing and social login onboarding.
Discipline: Visual Art (algorithmic art exhibition). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a algorithmic art exhibition action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The algorithmic art exhibition flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA visual-art-artswap-network-23 · Base · ArtSwap Network =====
Page: https://arcprompts.lovable.app/ideas/visual-art-artswap-network-23

Build "ArtSwap Network" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Enable painters and illustrators to swap artworks onchain with gasless wallet bootstrapped by social login.
Discipline: Visual Art (visual art trades). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a visual art trades action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The visual art trades flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA visual-art-canvas-chronicles-0 · Base · Canvas Chronicles =====
Page: https://arcprompts.lovable.app/ideas/visual-art-canvas-chronicles-0

Build "Canvas Chronicles" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Securely mint and track authentic painting portfolios with verifiable creation history.
Discipline: Visual Art (painting portfolios). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a painting portfolios work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The painting portfolios flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA visual-art-sketch-stamp-1 · Base · Sketch Stamp =====
Page: https://arcprompts.lovable.app/ideas/visual-art-sketch-stamp-1

Build "Sketch Stamp" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Authenticate and timestamp early illustration drafts to prove originality and creative process.
Discipline: Visual Art (illustration drafts). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a illustration drafts work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The illustration drafts flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA visual-art-generative-genesis-2 · Base · Generative Genesis =====
Page: https://arcprompts.lovable.app/ideas/visual-art-generative-genesis-2

Build "Generative Genesis" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Track and mint each generative art iteration as unique collectible tokens.
Discipline: Visual Art (generative art iterations). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a generative art iterations work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The generative art iterations flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA visual-art-gallery-gatekeeper-3 · Base · Gallery Gatekeeper =====
Page: https://arcprompts.lovable.app/ideas/visual-art-gallery-gatekeeper-3

Build "Gallery Gatekeeper" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Enable galleries to mint and verify provenance of physical artwork displayed or sold.
Discipline: Visual Art (gallery asset curation). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a gallery asset curation work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The gallery asset curation flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA visual-art-color-ledger-4 · Base · Color Ledger =====
Page: https://arcprompts.lovable.app/ideas/visual-art-color-ledger-4

Build "Color Ledger" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint unique NFTs capturing and securing artist-specific color palettes and schemes.
Discipline: Visual Art (color palette preservation). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a color palette preservation work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The color palette preservation flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA visual-art-brushstroke-chain-5 · Base · Brushstroke Chain =====
Page: https://arcprompts.lovable.app/ideas/visual-art-brushstroke-chain-5

Build "Brushstroke Chain" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Record and mint signature brushstroke styles as NFTs for artist branding and licensing.
Discipline: Visual Art (brush technique archives). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a brush technique archives work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The brush technique archives flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA visual-art-minted-murals-6 · Base · Minted Murals =====
Page: https://arcprompts.lovable.app/ideas/visual-art-minted-murals-6

Build "Minted Murals" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Authenticate and immortalize public murals with creator-owned NFT provenance tokens.
Discipline: Visual Art (public mural documentation). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a public mural documentation work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The public mural documentation flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA visual-art-framechain-7 · Base · FrameChain =====
Page: https://arcprompts.lovable.app/ideas/visual-art-framechain-7

Build "FrameChain" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Control and verify reproduction rights of artworks via mintable provenance NFTs.
Discipline: Visual Art (art reproduction control). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a art reproduction control work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The art reproduction control flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA visual-art-illustrator-s-imprint-8 · Base · Illustrator’s Imprint =====
Page: https://arcprompts.lovable.app/ideas/visual-art-illustrator-s-imprint-8

Build "Illustrator’s Imprint" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint signed digital prints with verifiable creator provenance directly on the blockchain.
Discipline: Visual Art (signed digital prints). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a signed digital prints work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The signed digital prints flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA visual-art-provenance-palette-9 · Base · Provenance Palette =====
Page: https://arcprompts.lovable.app/ideas/visual-art-provenance-palette-9

Build "Provenance Palette" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Digitally certify and mint provenance tokens for unique physical artist palettes.
Discipline: Visual Art (artist palette provenance). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a artist palette provenance work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The artist palette provenance flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA visual-art-pixel-provenance-10 · Base · Pixel Provenance =====
Page: https://arcprompts.lovable.app/ideas/visual-art-pixel-provenance-10

Build "Pixel Provenance" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Securely mint pixel art pieces with immutable creator provenance and IPFS metadata.
Discipline: Visual Art (pixel art authentication). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a pixel art authentication work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The pixel art authentication flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA visual-art-exhibit-echo-11 · Base · Exhibit Echo =====
Page: https://arcprompts.lovable.app/ideas/visual-art-exhibit-echo-11

Build "Exhibit Echo" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Preserve virtual gallery exhibits with creator-owned NFT provenance linked to IPFS.
Discipline: Visual Art (virtual exhibition records). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a virtual exhibition records work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The virtual exhibition records flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA visual-art-storyboard-stamp-12 · Base · Storyboard Stamp =====
Page: https://arcprompts.lovable.app/ideas/visual-art-storyboard-stamp-12

Build "Storyboard Stamp" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint sequential NFTs to authenticate evolving concept art storyboards and ideas.
Discipline: Visual Art (concept art progression). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a concept art progression work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The concept art progression flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA visual-art-masterstroke-mint-13 · Base · Masterstroke Mint =====
Page: https://arcprompts.lovable.app/ideas/visual-art-masterstroke-mint-13

Build "Masterstroke Mint" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Create immutable certificates of authenticity for signature artworks via NFT provenance mint.
Discipline: Visual Art (signature artwork certs). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a signature artwork certs work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The signature artwork certs flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA visual-art-layer-ledger-14 · Base · Layer Ledger =====
Page: https://arcprompts.lovable.app/ideas/visual-art-layer-ledger-14

Build "Layer Ledger" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Track and mint individual painting layers proving creative process and ownership.
Discipline: Visual Art (digital painting layers). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a digital painting layers work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The digital painting layers flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA visual-art-artchain-auction-15 · Base · Artchain Auction =====
Page: https://arcprompts.lovable.app/ideas/visual-art-artchain-auction-15

Build "Artchain Auction" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Integrate provenance minting into art auctions to verify authenticity and creator royalties.
Discipline: Visual Art (secondary art sales). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a secondary art sales work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The secondary art sales flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA visual-art-color-code-vault-16 · Base · Color Code Vault =====
Page: https://arcprompts.lovable.app/ideas/visual-art-color-code-vault-16

Build "Color Code Vault" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Securely store and prove origin of proprietary digital color codes with mintable NFTs.
Discipline: Visual Art (digital color codes). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a digital color codes work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The digital color codes flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA visual-art-art-mentor-mark-17 · Base · Art Mentor Mark =====
Page: https://arcprompts.lovable.app/ideas/visual-art-art-mentor-mark-17

Build "Art Mentor Mark" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint NFTs to certify mentorship lineage and creative influence among artists.
Discipline: Visual Art (art mentorship proof). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a art mentorship proof work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The art mentorship proof flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA visual-art-signature-seal-18 · Base · Signature Seal =====
Page: https://arcprompts.lovable.app/ideas/visual-art-signature-seal-18

Build "Signature Seal" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Allow artists to mint unique digital signatures as NFT proof of authorship and authenticity.
Discipline: Visual Art (digital signature minting). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a digital signature minting work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The digital signature minting flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA visual-art-nft-mirror-19 · Base · NFT Mirror =====
Page: https://arcprompts.lovable.app/ideas/visual-art-nft-mirror-19

Build "NFT Mirror" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint paired NFTs representing original and reflected artworks to showcase creative duality.
Discipline: Visual Art (artistic reflection sets). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a artistic reflection sets work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The artistic reflection sets flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA visual-art-art-rewind-20 · Base · Art Rewind =====
Page: https://arcprompts.lovable.app/ideas/visual-art-art-rewind-20

Build "Art Rewind" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint stepwise NFTs documenting artwork creation stages for replay and provenance.
Discipline: Visual Art (creative process playback). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a creative process playback work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The creative process playback flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA visual-art-gallery-provenance-21 · Base · Gallery Provenance =====
Page: https://arcprompts.lovable.app/ideas/visual-art-gallery-provenance-21

Build "Gallery Provenance" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Digitally certify artwork origin and gallery exhibition history onchain with NFTs.
Discipline: Visual Art (physical gallery tracking). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a physical gallery tracking work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The physical gallery tracking flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA visual-art-nft-colorgram-22 · Base · NFT Colorgram =====
Page: https://arcprompts.lovable.app/ideas/visual-art-nft-colorgram-22

Build "NFT Colorgram" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Create NFTs representing exclusive color-themed artworks with immutable provenance.
Discipline: Visual Art (chromatic art NFTs). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a chromatic art NFTs work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The chromatic art NFTs flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA visual-art-motion-mint-23 · Base · Motion Mint =====
Page: https://arcprompts.lovable.app/ideas/visual-art-motion-mint-23

Build "Motion Mint" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint creator-owned NFTs for animated illustrations backed by IPFS-stored assets.
Discipline: Visual Art (animated illustration ownership). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a animated illustration ownership work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The animated illustration ownership flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA visual-art-provenance-palette-24 · Base · Provenance Palette =====
Page: https://arcprompts.lovable.app/ideas/visual-art-provenance-palette-24

Build "Provenance Palette" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Digitize and mint physical palette images as NFTs preserving unique artist color mixes.
Discipline: Visual Art (physical palette digitization). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a physical palette digitization work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The physical palette digitization flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA video-framechain-auth-0 · Base · FrameChain Auth =====
Page: https://arcprompts.lovable.app/ideas/video-framechain-auth-0

Build "FrameChain Auth" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Verify and timestamp original video frames onchain to prove authentic content ownership instantly.
Discipline: Videography & Film (video copyright). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a video copyright item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The video copyright flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA video-editversion-ledger-1 · Base · EditVersion Ledger =====
Page: https://arcprompts.lovable.app/ideas/video-editversion-ledger-1

Build "EditVersion Ledger" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Track and verify every edit version of a video project transparently on the blockchain.
Discipline: Videography & Film (edit history). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a edit history item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The edit history flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA video-cliplicense-swap-2 · Base · ClipLicense Swap =====
Page: https://arcprompts.lovable.app/ideas/video-cliplicense-swap-2

Build "ClipLicense Swap" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Facilitate secure, onchain licensing and transfer of video clips between creators.
Discipline: Videography & Film (licensed assets). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a licensed assets item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The licensed assets flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA video-colorgrade-nft-3 · Base · ColorGrade NFT =====
Page: https://arcprompts.lovable.app/ideas/video-colorgrade-nft-3

Build "ColorGrade NFT" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Create and trade unique onchain color grade presets as NFTs for creative reuse.
Discipline: Videography & Film (color grading). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a color grading item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The color grading flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA video-framerate-token-4 · Base · FrameRate Token =====
Page: https://arcprompts.lovable.app/ideas/video-framerate-token-4

Build "FrameRate Token" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Store and share verified video metadata like frame rate and resolution securely onchain.
Discipline: Videography & Film (video metadata). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a video metadata item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The video metadata flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA video-scenesync-chain-5 · Base · SceneSync Chain =====
Page: https://arcprompts.lovable.app/ideas/video-scenesync-chain-5

Build "SceneSync Chain" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Enable real-time, onchain synchronization of collaborative video editing sessions.
Discipline: Videography & Film (collaborative editing). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a collaborative editing item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The collaborative editing flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA video-contenttrust-badge-6 · Base · ContentTrust Badge =====
Page: https://arcprompts.lovable.app/ideas/video-contenttrust-badge-6

Build "ContentTrust Badge" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Award verifiable trust badges onchain for authentic and verified video content.
Discipline: Videography & Film (video authenticity). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a video authenticity item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The video authenticity flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA video-royaltysplit-dao-7 · Base · RoyaltySplit DAO =====
Page: https://arcprompts.lovable.app/ideas/video-royaltysplit-dao-7

Build "RoyaltySplit DAO" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Manage automatic onchain royalty splits among multiple video collaborators transparently.
Discipline: Videography & Film (creator royalties). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a creator royalties item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The creator royalties flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA video-scenetag-registry-8 · Base · SceneTag Registry =====
Page: https://arcprompts.lovable.app/ideas/video-scenetag-registry-8

Build "SceneTag Registry" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Register and verify scene tags onchain to improve searchable video content metadata.
Discipline: Videography & Film (scene metadata). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a scene metadata item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The scene metadata flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA video-scriptchain-ledger-9 · Base · ScriptChain Ledger =====
Page: https://arcprompts.lovable.app/ideas/video-scriptchain-ledger-9

Build "ScriptChain Ledger" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Timestamp and verify screenplay versions onchain to protect script authorship claims.
Discipline: Videography & Film (screenplay tracking). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a screenplay tracking item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The screenplay tracking flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA video-clipstake-platform-10 · Base · ClipStake Platform =====
Page: https://arcprompts.lovable.app/ideas/video-clipstake-platform-10

Build "ClipStake Platform" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Stake tokens on promising clips to support creators and earn rewards via smart contracts.
Discipline: Videography & Film (video staking). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a video staking item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The video staking flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA video-autosubtitle-mint-11 · Base · AutoSubtitle Mint =====
Page: https://arcprompts.lovable.app/ideas/video-autosubtitle-mint-11

Build "AutoSubtitle Mint" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Generate and store verified subtitles onchain to guarantee transcript authenticity.
Discipline: Videography & Film (subtitle generation). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a subtitle generation item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The subtitle generation flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA video-videocollab-dao-12 · Base · VideoCollab DAO =====
Page: https://arcprompts.lovable.app/ideas/video-videocollab-dao-12

Build "VideoCollab DAO" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Decentralize video project management via DAOs for transparent decision-making and funding.
Discipline: Videography & Film (collaborative project management). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a collaborative project management item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The collaborative project management flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA video-nftscene-frames-13 · Base · NFTScene Frames =====
Page: https://arcprompts.lovable.app/ideas/video-nftscene-frames-13

Build "NFTScene Frames" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint key video frames as NFTs to sell exclusive ownership of iconic moments.
Discipline: Videography & Film (unique video moments). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a unique video moments item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The unique video moments flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA video-chainfeedback-loop-14 · Base · ChainFeedback Loop =====
Page: https://arcprompts.lovable.app/ideas/video-chainfeedback-loop-14

Build "ChainFeedback Loop" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Collect and verify editorial feedback on video edits onchain to improve collaboration.
Discipline: Videography & Film (editorial feedback). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a editorial feedback item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The editorial feedback flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA video-sceneunlock-token-15 · Base · SceneUnlock Token =====
Page: https://arcprompts.lovable.app/ideas/video-sceneunlock-token-15

Build "SceneUnlock Token" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Token-gated access to exclusive video scenes ensuring verified viewer entitlements.
Discipline: Videography & Film (content access control). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a content access control item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The content access control flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA video-colorswap-market-16 · Base · ColorSwap Market =====
Page: https://arcprompts.lovable.app/ideas/video-colorswap-market-16

Build "ColorSwap Market" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Trade and license unique color palettes onchain for licensed use in video projects.
Discipline: Videography & Film (color palette trading). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a color palette trading item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The color palette trading flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA video-clipproof-archive-17 · Base · ClipProof Archive =====
Page: https://arcprompts.lovable.app/ideas/video-clipproof-archive-17

Build "ClipProof Archive" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Archive important video clips immutably onchain for indisputable provenance and retrieval.
Discipline: Videography & Film (immutable clip storage). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a immutable clip storage item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The immutable clip storage flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA video-livecut-chain-18 · Base · LiveCut Chain =====
Page: https://arcprompts.lovable.app/ideas/video-livecut-chain-18

Build "LiveCut Chain" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Track edits and transitions in live video streams securely onchain for transparent records.
Discipline: Videography & Film (live edit tracking). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a live edit tracking item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The live edit tracking flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA video-captiontag-nft-19 · Base · CaptionTag NFT =====
Page: https://arcprompts.lovable.app/ideas/video-captiontag-nft-19

Build "CaptionTag NFT" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint caption sets as NFTs to prove creative ownership and enable resale.
Discipline: Videography & Film (caption ownership). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a caption ownership item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The caption ownership flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA video-framerate-oracle-20 · Base · FrameRate Oracle =====
Page: https://arcprompts.lovable.app/ideas/video-framerate-oracle-20

Build "FrameRate Oracle" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Use onchain oracles to validate frame rate data ensuring consistency across platforms.
Discipline: Videography & Film (metadata validation). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a metadata validation item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The metadata validation flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA video-reelrights-dao-21 · Base · ReelRights DAO =====
Page: https://arcprompts.lovable.app/ideas/video-reelrights-dao-21

Build "ReelRights DAO" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Decentralize video copyright decisions and dispute resolutions via governance DAOs.
Discipline: Videography & Film (copyright governance). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a copyright governance item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The copyright governance flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA video-cliptip-payments-22 · Base · ClipTip Payments =====
Page: https://arcprompts.lovable.app/ideas/video-cliptip-payments-22

Build "ClipTip Payments" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Enable instant micro-tipping to video creators with onchain transparency and low fees.
Discipline: Videography & Film (micro-tipping). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a micro-tipping item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The micro-tipping flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA video-motiontrack-chain-23 · Base · MotionTrack Chain =====
Page: https://arcprompts.lovable.app/ideas/video-motiontrack-chain-23

Build "MotionTrack Chain" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Record verified motion tracking data onchain for transparent post-production workflows.
Discipline: Videography & Film (motion metadata). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a motion metadata item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The motion metadata flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA video-scenemint-hub-24 · Base · SceneMint Hub =====
Page: https://arcprompts.lovable.app/ideas/video-scenemint-hub-24

Build "SceneMint Hub" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint and trade unique video scenes as NFTs to unlock new revenue streams for creators.
Discipline: Videography & Film (scene NFT marketplace). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a scene NFT marketplace item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The scene NFT marketplace flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA video-framesync-ledger-0 · Base · FrameSync Ledger =====
Page: https://arcprompts.lovable.app/ideas/video-framesync-ledger-0

Build "FrameSync Ledger" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Track and manage video edits through IPFS to ensure lossless version history for creators.
Discipline: Videography & Film (version control). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a version control sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The version control flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA video-clipstamp-vault-1 · Base · ClipStamp Vault =====
Page: https://arcprompts.lovable.app/ideas/video-clipstamp-vault-1

Build "ClipStamp Vault" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Securely timestamp video clips onchain to verify original creation times and prevent plagiarism.
Discipline: Videography & Film (content authentication). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a content authentication sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The content authentication flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA video-storyboard-chain-2 · Base · Storyboard Chain =====
Page: https://arcprompts.lovable.app/ideas/video-storyboard-chain-2

Build "Storyboard Chain" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Create IPFS-backed interactive storyboards that persistently link video plans and references.
Discipline: Videography & Film (preproduction planning). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a preproduction planning sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The preproduction planning flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA video-colorgrade-provenance-3 · Base · ColorGrade Provenance =====
Page: https://arcprompts.lovable.app/ideas/video-colorgrade-provenance-3

Build "ColorGrade Provenance" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Track and share editable color grading profiles via IPFS for collaborative and consistent grading.
Discipline: Videography & Film (color grading). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a color grading sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The color grading flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA video-motionmask-archive-4 · Base · MotionMask Archive =====
Page: https://arcprompts.lovable.app/ideas/video-motionmask-archive-4

Build "MotionMask Archive" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Store and share masking templates on IPFS to reuse and collaborate on complex video effects.
Discipline: Videography & Film (masking and effects). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a masking and effects sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The masking and effects flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA video-soundsync-chain-5 · Base · SoundSync Chain =====
Page: https://arcprompts.lovable.app/ideas/video-soundsync-chain-5

Build "SoundSync Chain" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Synchronize and store audio-video alignment data on IPFS for seamless collaborative editing.
Discipline: Videography & Film (audio synchronization). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a audio synchronization sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The audio synchronization flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA video-cutlist-ledger-6 · Base · CutList Ledger =====
Page: https://arcprompts.lovable.app/ideas/video-cutlist-ledger-6

Build "CutList Ledger" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin and track cut decisions and timelines on IPFS for transparent editing history and audit trails.
Discipline: Videography & Film (editing workflows). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a editing workflows sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The editing workflows flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA video-vfx-asset-chain-7 · Base · VFX Asset Chain =====
Page: https://arcprompts.lovable.app/ideas/video-vfx-asset-chain-7

Build "VFX Asset Chain" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Decentralize and share VFX assets metadata on IPFS to streamline collaborative asset management.
Discipline: Videography & Film (visual effects). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a visual effects sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The visual effects flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA video-captioncast-ipfs-8 · Base · CaptionCast IPFS =====
Page: https://arcprompts.lovable.app/ideas/video-captioncast-ipfs-8

Build "CaptionCast IPFS" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Store and distribute subtitle files on IPFS for reliable, versioned caption accessibility worldwide.
Discipline: Videography & Film (subtitling and captions). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a subtitling and captions sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The subtitling and captions flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA video-transcode-manifest-9 · Base · Transcode Manifest =====
Page: https://arcprompts.lovable.app/ideas/video-transcode-manifest-9

Build "Transcode Manifest" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin transcoding manifests on IPFS to track formats, resolutions, and settings transparently.
Discipline: Videography & Film (video encoding). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a video encoding sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The video encoding flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA video-loopprovenance-10 · Base · LoopProvenance =====
Page: https://arcprompts.lovable.app/ideas/video-loopprovenance-10

Build "LoopProvenance" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Store looped animation metadata on IPFS to verify originality and share reusable loop assets.
Discipline: Videography & Film (animation loops). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a animation loops sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The animation loops flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA video-scriptsync-chain-11 · Base · ScriptSync Chain =====
Page: https://arcprompts.lovable.app/ideas/video-scriptsync-chain-11

Build "ScriptSync Chain" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin and link script revisions and annotations on IPFS for collaborative screenplay editing.
Discipline: Videography & Film (script and dialogue). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a script and dialogue sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The script and dialogue flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA video-lensprofile-archive-12 · Base · LensProfile Archive =====
Page: https://arcprompts.lovable.app/ideas/video-lensprofile-archive-12

Build "LensProfile Archive" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Decentralize camera and lens profiles on IPFS for consistent color and exposure correction.
Discipline: Videography & Film (camera profiling). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a camera profiling sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The camera profiling flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA video-assetaudit-trail-13 · Base · AssetAudit Trail =====
Page: https://arcprompts.lovable.app/ideas/video-assetaudit-trail-13

Build "AssetAudit Trail" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin asset usage logs and metadata on IPFS to audit rights and permissions transparently.
Discipline: Videography & Film (media asset management). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a media asset management sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The media asset management flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA video-filterforge-ipfs-14 · Base · FilterForge IPFS =====
Page: https://arcprompts.lovable.app/ideas/video-filterforge-ipfs-14

Build "FilterForge IPFS" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Share and version custom video filters on IPFS for easy collaboration and reuse.
Discipline: Videography & Film (filter development). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a filter development sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The filter development flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA video-clipchain-marketplace-15 · Base · ClipChain Marketplace =====
Page: https://arcprompts.lovable.app/ideas/video-clipchain-marketplace-15

Build "ClipChain Marketplace" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Create decentralized marketplaces for licensed video clips pinned immutably on IPFS.
Discipline: Videography & Film (clip licensing). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a clip licensing sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The clip licensing flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA video-timelinetrace-ipfs-16 · Base · TimelineTrace IPFS =====
Page: https://arcprompts.lovable.app/ideas/video-timelinetrace-ipfs-16

Build "TimelineTrace IPFS" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin entire editing timelines on IPFS to enable persistent sharing and rollback across projects.
Discipline: Videography & Film (editing timeline). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a editing timeline sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The editing timeline flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA video-frameforge-ipfs-17 · Base · FrameForge IPFS =====
Page: https://arcprompts.lovable.app/ideas/video-frameforge-ipfs-17

Build "FrameForge IPFS" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Attach and store notes and metadata to individual frames on IPFS for detailed editorial feedback.
Discipline: Videography & Film (frame-specific notes). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a frame-specific notes sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The frame-specific notes flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA video-effectchain-library-18 · Base · EffectChain Library =====
Page: https://arcprompts.lovable.app/ideas/video-effectchain-library-18

Build "EffectChain Library" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin and share effect preset libraries on IPFS for repeatable, consistent video stylizations.
Discipline: Videography & Film (effect presets). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a effect presets sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The effect presets flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA video-posterchain-assets-19 · Base · PosterChain Assets =====
Page: https://arcprompts.lovable.app/ideas/video-posterchain-assets-19

Build "PosterChain Assets" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Store and share film poster and thumbnail assets on IPFS for consistent branding across platforms.
Discipline: Videography & Film (promotional imagery). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a promotional imagery sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The promotional imagery flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA video-eventsync-ledger-20 · Base · EventSync Ledger =====
Page: https://arcprompts.lovable.app/ideas/video-eventsync-ledger-20

Build "EventSync Ledger" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin and synchronize live edit events on IPFS for verifiable broadcast and post-event review.
Discipline: Videography & Film (live editing events). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a live editing events sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The live editing events flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA video-transitionchain-vault-21 · Base · TransitionChain Vault =====
Page: https://arcprompts.lovable.app/ideas/video-transitionchain-vault-21

Build "TransitionChain Vault" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Store reusable video transition presets on IPFS to ensure permanent, shareable effects.
Discipline: Videography & Film (transition effects). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a transition effects sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The transition effects flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA video-metadatamesh-ipfs-22 · Base · MetadataMesh IPFS =====
Page: https://arcprompts.lovable.app/ideas/video-metadatamesh-ipfs-22

Build "MetadataMesh IPFS" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin enriched metadata sets on IPFS to enhance archival, search, and retrieval of video content.
Discipline: Videography & Film (metadata management). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a metadata management sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The metadata management flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA video-shotlist-ledger-23 · Base · ShotList Ledger =====
Page: https://arcprompts.lovable.app/ideas/video-shotlist-ledger-23

Build "ShotList Ledger" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin shot lists and scene breakdowns on IPFS for secure, shared production references.
Discipline: Videography & Film (production tracking). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a production tracking sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The production tracking flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA video-seamless-clip-shares-0 · Base · Seamless Clip Shares =====
Page: https://arcprompts.lovable.app/ideas/video-seamless-clip-shares-0

Build "Seamless Clip Shares" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Share video edits instantly without gas fees, enabling smooth collaboration among creators.
Discipline: Videography & Film (collaborative editing). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a collaborative editing action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The collaborative editing flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA video-tokenized-cut-approval-1 · Base · Tokenized Cut Approval =====
Page: https://arcprompts.lovable.app/ideas/video-tokenized-cut-approval-1

Build "Tokenized Cut Approval" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Enable editors and clients to approve cuts securely via onchain, without gas barriers.
Discipline: Videography & Film (edit review). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a edit review action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The edit review flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA video-clip-provenance-ledger-2 · Base · Clip Provenance Ledger =====
Page: https://arcprompts.lovable.app/ideas/video-clip-provenance-ledger-2

Build "Clip Provenance Ledger" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Verify original footage sources with onchain provenance that users access gaslessly.
Discipline: Videography & Film (authenticity tracking). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a authenticity tracking action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The authenticity tracking flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA video-sponsored-effects-marketplace-3 · Base · Sponsored Effects Marketplace =====
Page: https://arcprompts.lovable.app/ideas/video-sponsored-effects-marketplace-3

Build "Sponsored Effects Marketplace" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Buy and sell video effects licenses seamlessly with gasless wallet transactions.
Discipline: Videography & Film (visual effects trading). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a visual effects trading action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The visual effects trading flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA video-gasless-frame-tokens-4 · Base · Gasless Frame Tokens =====
Page: https://arcprompts.lovable.app/ideas/video-gasless-frame-tokens-4

Build "Gasless Frame Tokens" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint and trade unique video frames as NFTs without ever paying gas fees.
Discipline: Videography & Film (NFT video frames). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a NFT video frames action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The NFT video frames flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA video-instant-sponsor-rewards-5 · Base · Instant Sponsor Rewards =====
Page: https://arcprompts.lovable.app/ideas/video-instant-sponsor-rewards-5

Build "Instant Sponsor Rewards" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Reward fans instantly onchain with tokens during video interactions without gas hurdles.
Discipline: Videography & Film (creator monetization). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a creator monetization action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The creator monetization flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA video-collaborative-scene-ledger-6 · Base · Collaborative Scene Ledger =====
Page: https://arcprompts.lovable.app/ideas/video-collaborative-scene-ledger-6

Build "Collaborative Scene Ledger" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Track scene contributions by multiple creators transparently with zero gas cost onchain.
Discipline: Videography & Film (scene co-creation). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a scene co-creation action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The scene co-creation flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA video-script-to-screen-sync-7 · Base · Script-to-Screen Sync =====
Page: https://arcprompts.lovable.app/ideas/video-script-to-screen-sync-7

Build "Script-to-Screen Sync" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Sync script changes and video edits onchain for teams without forcing gas payments.
Discipline: Videography & Film (production alignment). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a production alignment action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The production alignment flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA video-gasless-licensing-hub-8 · Base · Gasless Licensing Hub =====
Page: https://arcprompts.lovable.app/ideas/video-gasless-licensing-hub-8

Build "Gasless Licensing Hub" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
License stock footage instantly with zero gas fees for hassle-free transactions.
Discipline: Videography & Film (rights management). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a rights management action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The rights management flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA video-verified-creator-ids-9 · Base · Verified Creator IDs =====
Page: https://arcprompts.lovable.app/ideas/video-verified-creator-ids-9

Build "Verified Creator IDs" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Enable filmmakers to verify credentials onchain with easy sign-in and no gas fees.
Discipline: Videography & Film (identity verification). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a identity verification action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The identity verification flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA video-sponsored-review-tokens-10 · Base · Sponsored Review Tokens =====
Page: https://arcprompts.lovable.app/ideas/video-sponsored-review-tokens-10

Build "Sponsored Review Tokens" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Viewers reward video feedback with tokens instantly, without seeing transaction fees.
Discipline: Videography & Film (audience feedback). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a audience feedback action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The audience feedback flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA video-chain-backed-storyboards-11 · Base · Chain-Backed Storyboards =====
Page: https://arcprompts.lovable.app/ideas/video-chain-backed-storyboards-11

Build "Chain-Backed Storyboards" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Store and share editable storyboards onchain with instant, gas-free updates.
Discipline: Videography & Film (previsualization). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a previsualization action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The previsualization flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA video-gasless-release-commits-12 · Base · Gasless Release Commits =====
Page: https://arcprompts.lovable.app/ideas/video-gasless-release-commits-12

Build "Gasless Release Commits" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Commit video edits onchain transparently with zero gas cost for creators.
Discipline: Videography & Film (version control). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a version control action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The version control flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA video-tokenized-b-roll-access-13 · Base · Tokenized B-Roll Access =====
Page: https://arcprompts.lovable.app/ideas/video-tokenized-b-roll-access-13

Build "Tokenized B-Roll Access" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Grant and revoke B-roll access quickly via token ownership with no gas fees.
Discipline: Videography & Film (footage licensing). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a footage licensing action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The footage licensing flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA video-sponsored-collab-invites-14 · Base · Sponsored Collab Invites =====
Page: https://arcprompts.lovable.app/ideas/video-sponsored-collab-invites-14

Build "Sponsored Collab Invites" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Invite collaborators to projects through gas-free, onchain wallet interactions.
Discipline: Videography & Film (team management). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a team management action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The team management flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA video-privy-clip-bounties-15 · Base · Privy Clip Bounties =====
Page: https://arcprompts.lovable.app/ideas/video-privy-clip-bounties-15

Build "Privy Clip Bounties" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Reward contributors for clip submissions instantly with gas-free sponsor transactions.
Discipline: Videography & Film (crowdsourced footage). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a crowdsourced footage action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The crowdsourced footage flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA video-chain-stamped-edits-16 · Base · Chain-Stamped Edits =====
Page: https://arcprompts.lovable.app/ideas/video-chain-stamped-edits-16

Build "Chain-Stamped Edits" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Stamp finalized edits onchain instantly to prove authenticity without gas hassles.
Discipline: Videography & Film (edit authenticity). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a edit authenticity action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The edit authenticity flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA video-gasless-asset-sync-17 · Base · Gasless Asset Sync =====
Page: https://arcprompts.lovable.app/ideas/video-gasless-asset-sync-17

Build "Gasless Asset Sync" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Sync media assets across devices and collaborators onchain with no gas fees.
Discipline: Videography & Film (media syncing). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a media syncing action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The media syncing flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA video-token-gate-premieres-18 · Base · Token Gate Premieres =====
Page: https://arcprompts.lovable.app/ideas/video-token-gate-premieres-18

Build "Token Gate Premieres" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Host video premieres gated by token ownership with smooth, gasless access.
Discipline: Videography & Film (exclusive screenings). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a exclusive screenings action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The exclusive screenings flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA video-sponsored-clip-challenges-19 · Base · Sponsored Clip Challenges =====
Page: https://arcprompts.lovable.app/ideas/video-sponsored-clip-challenges-19

Build "Sponsored Clip Challenges" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Create video challenges rewarding participation instantly with no gas transaction fees.
Discipline: Videography & Film (user engagement). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a user engagement action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The user engagement flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA video-gasless-comment-tokens-20 · Base · Gasless Comment Tokens =====
Page: https://arcprompts.lovable.app/ideas/video-gasless-comment-tokens-20

Build "Gasless Comment Tokens" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Reward insightful video comments with tokens instantly without charging gas fees.
Discipline: Videography & Film (community feedback). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a community feedback action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The community feedback flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA video-chain-linked-shot-lists-21 · Base · Chain-Linked Shot Lists =====
Page: https://arcprompts.lovable.app/ideas/video-chain-linked-shot-lists-21

Build "Chain-Linked Shot Lists" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Manage shot lists collaboratively onchain without gas fees for production teams.
Discipline: Videography & Film (production planning). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a production planning action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The production planning flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA video-sponsored-render-credits-22 · Base · Sponsored Render Credits =====
Page: https://arcprompts.lovable.app/ideas/video-sponsored-render-credits-22

Build "Sponsored Render Credits" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Trade video render credits instantly via gasless onchain transactions.
Discipline: Videography & Film (compute resource sharing). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a compute resource sharing action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The compute resource sharing flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA video-gasless-frame-annotations-23 · Base · Gasless Frame Annotations =====
Page: https://arcprompts.lovable.app/ideas/video-gasless-frame-annotations-23

Build "Gasless Frame Annotations" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Annotate and share feedback on frames instantly with gasless transaction support.
Discipline: Videography & Film (video feedback). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a video feedback action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The video feedback flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA video-tokenized-music-sync-24 · Base · Tokenized Music Sync =====
Page: https://arcprompts.lovable.app/ideas/video-tokenized-music-sync-24

Build "Tokenized Music Sync" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
License music for videos via tokens with zero gas fees and seamless sign-in.
Discipline: Videography & Film (audio licensing). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a audio licensing action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The audio licensing flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA video-framelock-provenance-0 · Base · FrameLock Provenance =====
Page: https://arcprompts.lovable.app/ideas/video-framelock-provenance-0

Build "FrameLock Provenance" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Securely prove original shot ownership for video editors and creators to prevent unauthorized reuse.
Discipline: Videography & Film (shot authentication). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a shot authentication work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The shot authentication flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA video-colorgrade-ledger-1 · Base · ColorGrade Ledger =====
Page: https://arcprompts.lovable.app/ideas/video-colorgrade-ledger-1

Build "ColorGrade Ledger" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Track color correction versions with creator-owned tokens to maintain authentic grading history.
Discipline: Videography & Film (color grading). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a color grading work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The color grading flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA video-clipchain-remix-2 · Base · ClipChain Remix =====
Page: https://arcprompts.lovable.app/ideas/video-clipchain-remix-2

Build "ClipChain Remix" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint provenance tokens for remixed clips to credit original and derivative creators fairly.
Discipline: Videography & Film (video remixing). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a video remixing work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The video remixing flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA video-scenereveal-rights-3 · Base · SceneReveal Rights =====
Page: https://arcprompts.lovable.app/ideas/video-scenereveal-rights-3

Build "SceneReveal Rights" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Onchain minting proves scene ownership, simplifying licensing and reuse agreements for creators.
Discipline: Videography & Film (scene licensing). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a scene licensing work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The scene licensing flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA video-storyboard-stamp-4 · Base · Storyboard Stamp =====
Page: https://arcprompts.lovable.app/ideas/video-storyboard-stamp-4

Build "Storyboard Stamp" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint storyboards as NFT tokens to secure creative vision and enable easy sharing with teams.
Discipline: Videography & Film (previsualization). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a previsualization work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The previsualization flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA video-edittrace-ledger-5 · Base · EditTrace Ledger =====
Page: https://arcprompts.lovable.app/ideas/video-edittrace-ledger-5

Build "EditTrace Ledger" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Track and mint every edit step as NFTs to maintain transparent video edit workflows.
Discipline: Videography & Film (editing history). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a editing history work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The editing history flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA video-clipmint-archival-6 · Base · ClipMint Archival =====
Page: https://arcprompts.lovable.app/ideas/video-clipmint-archival-6

Build "ClipMint Archival" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint archival footage as NFTs to certify origin and enable monetization of historic clips.
Discipline: Videography & Film (archival footage). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a archival footage work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The archival footage flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA video-scriptproof-token-7 · Base · ScriptProof Token =====
Page: https://arcprompts.lovable.app/ideas/video-scriptproof-token-7

Build "ScriptProof Token" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Secure scripts as creator-owned NFTs to prevent plagiarism and prove original authorship.
Discipline: Videography & Film (script authenticity). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a script authenticity work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The script authenticity flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA video-moodboard-mint-8 · Base · Moodboard Mint =====
Page: https://arcprompts.lovable.app/ideas/video-moodboard-mint-8

Build "Moodboard Mint" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Create NFT-backed moodboards to validate and share artistic vision securely with collaborators.
Discipline: Videography & Film (visual concepting). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a visual concepting work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The visual concepting flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA video-soundsync-provenance-9 · Base · SoundSync Provenance =====
Page: https://arcprompts.lovable.app/ideas/video-soundsync-provenance-9

Build "SoundSync Provenance" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint sound edits as NFTs linked to videos to verify audio-visual synchronization authenticity.
Discipline: Videography & Film (audio synchronization). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a audio synchronization work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The audio synchronization flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA video-titletrack-tokens-10 · Base · TitleTrack Tokens =====
Page: https://arcprompts.lovable.app/ideas/video-titletrack-tokens-10

Build "TitleTrack Tokens" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint unique title animations NFTs to protect and share original animated intros.
Discipline: Videography & Film (title animation). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a title animation work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The title animation flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA video-lensflare-ledger-11 · Base · LensFlare Ledger =====
Page: https://arcprompts.lovable.app/ideas/video-lensflare-ledger-11

Build "LensFlare Ledger" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Prove originality of lens flare effects by minting creator-owned tokens of effect presets.
Discipline: Videography & Film (visual effects). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a visual effects work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The visual effects flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA video-cutsequence-proof-12 · Base · CutSequence Proof =====
Page: https://arcprompts.lovable.app/ideas/video-cutsequence-proof-12

Build "CutSequence Proof" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Secure entire editing sequences as NFTs to confirm edit ownership and version control.
Discipline: Videography & Film (editing sequence). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a editing sequence work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The editing sequence flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA video-filterforge-token-13 · Base · FilterForge Token =====
Page: https://arcprompts.lovable.app/ideas/video-filterforge-token-13

Build "FilterForge Token" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint original video filter presets as NFTs to protect and monetize unique creative effects.
Discipline: Videography & Film (video filters). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a video filters work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The video filters flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA video-vlogproof-mint-14 · Base · VlogProof Mint =====
Page: https://arcprompts.lovable.app/ideas/video-vlogproof-mint-14

Build "VlogProof Mint" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Authenticate vlogs via NFT tokens to assure viewers of original creator ownership and date.
Discipline: Videography & Film (content authenticity). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a content authenticity work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The content authenticity flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA video-motionmap-token-15 · Base · MotionMap Token =====
Page: https://arcprompts.lovable.app/ideas/video-motionmap-token-15

Build "MotionMap Token" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint motion tracking data as NFTs to verify originality and usage rights.
Discipline: Videography & Film (motion tracking). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a motion tracking work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The motion tracking flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA video-overlay-origin-16 · Base · Overlay Origin =====
Page: https://arcprompts.lovable.app/ideas/video-overlay-origin-16

Build "Overlay Origin" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Protect original graphic overlays by minting each as immutable NFTs with creator attribution.
Discipline: Videography & Film (graphic overlays). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a graphic overlays work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The graphic overlays flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA video-subtitle-signet-17 · Base · Subtitle Signet =====
Page: https://arcprompts.lovable.app/ideas/video-subtitle-signet-17

Build "Subtitle Signet" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint subtitles as NFTs to certify translation accuracy and original captioning ownership.
Discipline: Videography & Film (captioning). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a captioning work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The captioning flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA video-trailertrace-mint-18 · Base · TrailerTrace Mint =====
Page: https://arcprompts.lovable.app/ideas/video-trailertrace-mint-18

Build "TrailerTrace Mint" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Securely mint promotional trailers as NFTs to confirm authenticity and release dates.
Discipline: Videography & Film (promotional cuts). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a promotional cuts work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The promotional cuts flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA video-gift-provenance-19 · Base · GIFt Provenance =====
Page: https://arcprompts.lovable.app/ideas/video-gift-provenance-19

Build "GIFt Provenance" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Create creator-owned NFT tokens for animated GIFs to protect and monetize viral clips.
Discipline: Videography & Film (animated GIFs). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a animated GIFs work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The animated GIFs flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA video-dronefootage-token-20 · Base · DroneFootage Token =====
Page: https://arcprompts.lovable.app/ideas/video-dronefootage-token-20

Build "DroneFootage Token" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint drone videos as provenance NFTs to secure unique aerial shot copyrights.
Discipline: Videography & Film (aerial videography). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a aerial videography work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The aerial videography flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA video-timelapse-token-21 · Base · TimeLapse Token =====
Page: https://arcprompts.lovable.app/ideas/video-timelapse-token-21

Build "TimeLapse Token" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Secure time-lapse video originality by minting as NFTs with immutable timestamps.
Discipline: Videography & Film (time-lapse videography). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a time-lapse videography work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The time-lapse videography flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA video-multicam-mint-22 · Base · Multicam Mint =====
Page: https://arcprompts.lovable.app/ideas/video-multicam-mint-22

Build "Multicam Mint" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint synchronized multicam edits as NFTs to prove complex edit ownership and authenticity.
Discipline: Videography & Film (multi-camera editing). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a multi-camera editing work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The multi-camera editing flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA video-tutorialtoken-vault-23 · Base · TutorialToken Vault =====
Page: https://arcprompts.lovable.app/ideas/video-tutorialtoken-vault-23

Build "TutorialToken Vault" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint tutorial videos as NFTs to certify original teaching content and secure creator rights.
Discipline: Videography & Film (educational content). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a educational content work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The educational content flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA video-360proof-token-24 · Base · 360Proof Token =====
Page: https://arcprompts.lovable.app/ideas/video-360proof-token-24

Build "360Proof Token" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Secure authenticity of 360° videos by minting creator-owned provenance NFTs.
Discipline: Videography & Film (360-degree videography). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a 360-degree videography work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The 360-degree videography flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA photography-immutable-photo-rights-0 · Base · Immutable Photo Rights =====
Page: https://arcprompts.lovable.app/ideas/photography-immutable-photo-rights-0

Build "Immutable Photo Rights" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Securely register photo ownership and licensing rights on-chain with immutable proof.
Discipline: Photography (copyright registry). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a copyright registry item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The copyright registry flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA photography-onchain-photo-proof-1 · Base · Onchain Photo Proof =====
Page: https://arcprompts.lovable.app/ideas/photography-onchain-photo-proof-1

Build "Onchain Photo Proof" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Embed verifiable metadata on Sepolia to prove photo authenticity and timestamp creation.
Discipline: Photography (image authenticity). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a image authenticity item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The image authenticity flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA photography-smart-photo-royalties-2 · Base · Smart Photo Royalties =====
Page: https://arcprompts.lovable.app/ideas/photography-smart-photo-royalties-2

Build "Smart Photo Royalties" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Automate and transparently distribute photo royalties directly via Sepolia smart contracts.
Discipline: Photography (royalty automation). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a royalty automation item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The royalty automation flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA photography-collaborative-edits-chain-3 · Base · Collaborative Edits Chain =====
Page: https://arcprompts.lovable.app/ideas/photography-collaborative-edits-chain-3

Build "Collaborative Edits Chain" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Track photo edit histories and collaborators immutably on Sepolia for transparent teamwork.
Discipline: Photography (collaborative editing). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a collaborative editing item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The collaborative editing flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA photography-decentralized-portfolios-4 · Base · Decentralized Portfolios =====
Page: https://arcprompts.lovable.app/ideas/photography-decentralized-portfolios-4

Build "Decentralized Portfolios" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Create and showcase decentralized photography portfolios verified on Sepolia smart contracts.
Discipline: Photography (photographer profiles). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a photographer profiles item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The photographer profiles flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA photography-onchain-usage-tracking-5 · Base · Onchain Usage Tracking =====
Page: https://arcprompts.lovable.app/ideas/photography-onchain-usage-tracking-5

Build "Onchain Usage Tracking" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Track and record photo usage and distribution on-chain in real time for accurate licensing.
Discipline: Photography (photo usage monitoring). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a photo usage monitoring item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The photo usage monitoring flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA photography-nft-prints-marketplace-6 · Base · NFT Prints Marketplace =====
Page: https://arcprompts.lovable.app/ideas/photography-nft-prints-marketplace-6

Build "NFT Prints Marketplace" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Sell limited edition photo prints linked to NFTs minted and verified on Sepolia.
Discipline: Photography (photo prints trading). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a photo prints trading item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The photo prints trading flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA photography-proof-of-capture-7 · Base · Proof of Capture =====
Page: https://arcprompts.lovable.app/ideas/photography-proof-of-capture-7

Build "Proof of Capture" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Validate photo capture location and time on-chain instantly using Sepolia smart contracts.
Discipline: Photography (capture verification). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a capture verification item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The capture verification flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA photography-smart-rights-marketplace-8 · Base · Smart Rights Marketplace =====
Page: https://arcprompts.lovable.app/ideas/photography-smart-rights-marketplace-8

Build "Smart Rights Marketplace" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Decentralized marketplace for buying and selling photo licenses managed by smart contracts.
Discipline: Photography (licensing exchange). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a licensing exchange item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The licensing exchange flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA photography-chain-verified-edits-9 · Base · Chain Verified Edits =====
Page: https://arcprompts.lovable.app/ideas/photography-chain-verified-edits-9

Build "Chain Verified Edits" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Verify authenticity and sequence of photo edits on-chain to certify editorial integrity.
Discipline: Photography (edit validation). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a edit validation item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The edit validation flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA photography-decentralized-feedback-10 · Base · Decentralized Feedback =====
Page: https://arcprompts.lovable.app/ideas/photography-decentralized-feedback-10

Build "Decentralized Feedback" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Gather verified community feedback on photos via Sepolia-based smart contract voting.
Discipline: Photography (community critique). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a community critique item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The community critique flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA photography-chain-provenance-logs-11 · Base · Chain Provenance Logs =====
Page: https://arcprompts.lovable.app/ideas/photography-chain-provenance-logs-11

Build "Chain Provenance Logs" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Track entire lifecycle and ownership history of photos on Sepolia for provenance assurance.
Discipline: Photography (provenance tracking). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a provenance tracking item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The provenance tracking flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA photography-onchain-photo-challenges-12 · Base · Onchain Photo Challenges =====
Page: https://arcprompts.lovable.app/ideas/photography-onchain-photo-challenges-12

Build "Onchain Photo Challenges" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Host transparent and decentralized photo contests with onchain submission and voting.
Discipline: Photography (contest management). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a contest management item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The contest management flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA photography-verified-client-contracts-13 · Base · Verified Client Contracts =====
Page: https://arcprompts.lovable.app/ideas/photography-verified-client-contracts-13

Build "Verified Client Contracts" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Draft and execute photo service contracts on Sepolia smart contracts, reducing disputes.
Discipline: Photography (client agreements). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a client agreements item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The client agreements flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA photography-tip-jar-integration-14 · Base · Tip Jar Integration =====
Page: https://arcprompts.lovable.app/ideas/photography-tip-jar-integration-14

Build "Tip Jar Integration" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Enable fans to tip photographers instantly via Sepolia smart contract wallets.
Discipline: Photography (microdonations). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a microdonations item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The microdonations flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA photography-chain-linked-exif-15 · Base · Chain-Linked EXIF =====
Page: https://arcprompts.lovable.app/ideas/photography-chain-linked-exif-15

Build "Chain-Linked EXIF" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Anchor and verify photo EXIF metadata on Sepolia to prevent tampering and ensure trust.
Discipline: Photography (metadata anchoring). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a metadata anchoring item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The metadata anchoring flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA photography-onchain-photo-licensing-16 · Base · Onchain Photo Licensing =====
Page: https://arcprompts.lovable.app/ideas/photography-onchain-photo-licensing-16

Build "Onchain Photo Licensing" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Create customizable photo license agreements executed automatically via Sepolia contracts.
Discipline: Photography (license contracts). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a license contracts item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The license contracts flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA photography-decentralized-photo-auctions-17 · Base · Decentralized Photo Auctions =====
Page: https://arcprompts.lovable.app/ideas/photography-decentralized-photo-auctions-17

Build "Decentralized Photo Auctions" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Run transparent auctions for rare photos secured and settled using Sepolia smart contracts.
Discipline: Photography (auction platform). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a auction platform item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The auction platform flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA photography-smart-watermark-registry-18 · Base · Smart Watermark Registry =====
Page: https://arcprompts.lovable.app/ideas/photography-smart-watermark-registry-18

Build "Smart Watermark Registry" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Register, track, and enforce photo watermarks rights via onchain smart contracts.
Discipline: Photography (watermark management). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a watermark management item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The watermark management flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA photography-chain-backed-photo-grants-19 · Base · Chain-Backed Photo Grants =====
Page: https://arcprompts.lovable.app/ideas/photography-chain-backed-photo-grants-19

Build "Chain-Backed Photo Grants" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Manage and distribute photography grant funds transparently on Sepolia smart contracts.
Discipline: Photography (funding management). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a funding management item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The funding management flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA photography-onchain-model-releases-20 · Base · Onchain Model Releases =====
Page: https://arcprompts.lovable.app/ideas/photography-onchain-model-releases-20

Build "Onchain Model Releases" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Digitally sign and store model release forms on Sepolia blockchain for immutable proof.
Discipline: Photography (legal documentation). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a legal documentation item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The legal documentation flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA photography-photo-data-monetization-21 · Base · Photo Data Monetization =====
Page: https://arcprompts.lovable.app/ideas/photography-photo-data-monetization-21

Build "Photo Data Monetization" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Monetize photo metadata and usage data transparently via Sepolia smart contracts.
Discipline: Photography (data marketplace). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a data marketplace item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The data marketplace flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA photography-chain-based-mentorship-22 · Base · Chain-based Mentorship =====
Page: https://arcprompts.lovable.app/ideas/photography-chain-based-mentorship-22

Build "Chain-based Mentorship" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Match photography mentors and mentees with verified contracts and session records onchain.
Discipline: Photography (educational matching). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a educational matching item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The educational matching flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA photography-onchain-photo-presets-23 · Base · Onchain Photo Presets =====
Page: https://arcprompts.lovable.app/ideas/photography-onchain-photo-presets-23

Build "Onchain Photo Presets" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Create, license, and verify photo editing presets with immutable smart contract records.
Discipline: Photography (preset licensing). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a preset licensing item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The preset licensing flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA photography-decentralized-event-coverage-24 · Base · Decentralized Event Coverage =====
Page: https://arcprompts.lovable.app/ideas/photography-decentralized-event-coverage-24

Build "Decentralized Event Coverage" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Coordinate and verify crowdsourced event photography via Sepolia smart contracts for reliability.
Discipline: Photography (crowdsourced photo event). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a crowdsourced photo event item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The crowdsourced photo event flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA photography-chainframe-archive-0 · Base · ChainFrame Archive =====
Page: https://arcprompts.lovable.app/ideas/photography-chainframe-archive-0

Build "ChainFrame Archive" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Securely store and verify photo archives with immutable IPFS-backed metadata for trusted provenance.
Discipline: Photography (photo archiving). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a photo archiving sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The photo archiving flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA photography-pinphoto-journal-1 · Base · PinPhoto Journal =====
Page: https://arcprompts.lovable.app/ideas/photography-pinphoto-journal-1

Build "PinPhoto Journal" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Verify and timestamp news photos on IPFS to ensure authentic, unaltered media for journalism.
Discipline: Photography (photojournalism documentation). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a photojournalism documentation sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The photojournalism documentation flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA photography-colorchain-palette-2 · Base · ColorChain Palette =====
Page: https://arcprompts.lovable.app/ideas/photography-colorchain-palette-2

Build "ColorChain Palette" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Save and share color grading presets and images as permanent IPFS assets for consistent workflow.
Discipline: Photography (color grading). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a color grading sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The color grading flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA photography-metaframe-vault-3 · Base · MetaFrame Vault =====
Page: https://arcprompts.lovable.app/ideas/photography-metaframe-vault-3

Build "MetaFrame Vault" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Embed and immutably store photo metadata on IPFS to preserve creator rights and data integrity.
Discipline: Photography (metadata embedding). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a metadata embedding sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The metadata embedding flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA photography-snapshot-ledger-4 · Base · Snapshot Ledger =====
Page: https://arcprompts.lovable.app/ideas/photography-snapshot-ledger-4

Build "Snapshot Ledger" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Create a decentralized ledger of photo licenses pinned to IPFS for transparent usage rights.
Discipline: Photography (photo licensing). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a photo licensing sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The photo licensing flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA photography-focusproof-network-5 · Base · FocusProof Network =====
Page: https://arcprompts.lovable.app/ideas/photography-focusproof-network-5

Build "FocusProof Network" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Record lens focus data alongside images on IPFS for verifiable sharpness and authenticity.
Discipline: Photography (focus tracking). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a focus tracking sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The focus tracking flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA photography-exposuretrace-6 · Base · ExposureTrace =====
Page: https://arcprompts.lovable.app/ideas/photography-exposuretrace-6

Build "ExposureTrace" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Store exposure settings and images together on IPFS to improve reproducibility and learning.
Discipline: Photography (exposure analysis). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a exposure analysis sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The exposure analysis flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA photography-momentmap-7 · Base · MomentMap =====
Page: https://arcprompts.lovable.app/ideas/photography-momentmap-7

Build "MomentMap" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin geotagged photos on IPFS to create a permanent, verifiable map of photographic moments.
Discipline: Photography (location tagging). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a location tagging sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The location tagging flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA photography-collabochain-studio-8 · Base · CollaboChain Studio =====
Page: https://arcprompts.lovable.app/ideas/photography-collabochain-studio-8

Build "CollaboChain Studio" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Share locked versions of photos and edits on IPFS for trustable collaborative workflows.
Discipline: Photography (collaborative editing). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a collaborative editing sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The collaborative editing flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA photography-nftrography-gallery-9 · Base · NFTrography Gallery =====
Page: https://arcprompts.lovable.app/ideas/photography-nftrography-gallery-9

Build "NFTrography Gallery" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint and pin unique photographic art on IPFS to guarantee immutable ownership and provenance.
Discipline: Photography (photo NFTs). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a photo NFTs sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The photo NFTs flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA photography-proofshot-certify-10 · Base · ProofShot Certify =====
Page: https://arcprompts.lovable.app/ideas/photography-proofshot-certify-10

Build "ProofShot Certify" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Authenticate original photos by pinning hashes and images on IPFS for proof of authenticity.
Discipline: Photography (image authentication). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a image authentication sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The image authentication flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA photography-chronocapture-log-11 · Base · ChronoCapture Log =====
Page: https://arcprompts.lovable.app/ideas/photography-chronocapture-log-11

Build "ChronoCapture Log" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin time-lapse image sequences on IPFS to preserve and share permanent chronological photo stories.
Discipline: Photography (time lapse). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a time lapse sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The time lapse flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA photography-lenslegacy-vault-12 · Base · LensLegacy Vault =====
Page: https://arcprompts.lovable.app/ideas/photography-lenslegacy-vault-12

Build "LensLegacy Vault" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Store detailed camera sensor data with images on IPFS to analyze vintage gear performance over time.
Discipline: Photography (camera data archival). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a camera data archival sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The camera data archival flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA photography-frameswap-marketplace-13 · Base · FrameSwap Marketplace =====
Page: https://arcprompts.lovable.app/ideas/photography-frameswap-marketplace-13

Build "FrameSwap Marketplace" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Trade and pin licensed photo assets on IPFS to enable decentralized, tamper-proof exchanges.
Discipline: Photography (photo asset exchange). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a photo asset exchange sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The photo asset exchange flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA photography-clipstatic-cdn-14 · Base · ClipStatic CDN =====
Page: https://arcprompts.lovable.app/ideas/photography-clipstatic-cdn-14

Build "ClipStatic CDN" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Distribute high-performance static photo assets pinned on IPFS for reliable global delivery.
Discipline: Photography (image delivery). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a image delivery sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The image delivery flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA photography-tokenizelight-15 · Base · TokenizeLight =====
Page: https://arcprompts.lovable.app/ideas/photography-tokenizelight-15

Build "TokenizeLight" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Create tokens linked to photos pinned on IPFS for secure, transparent rights and royalty tracking.
Discipline: Photography (rights management). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a rights management sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The rights management flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA photography-hdr-pinboard-16 · Base · HDR Pinboard =====
Page: https://arcprompts.lovable.app/ideas/photography-hdr-pinboard-16

Build "HDR Pinboard" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin multi-exposure HDR image sets on IPFS to ensure permanent, verifiable combination assets.
Discipline: Photography (high dynamic range). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a high dynamic range sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The high dynamic range flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA photography-cropchain-editor-17 · Base · CropChain Editor =====
Page: https://arcprompts.lovable.app/ideas/photography-cropchain-editor-17

Build "CropChain Editor" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Save crop presets and cropped images pinned on IPFS for exact reproducibility and sharing.
Discipline: Photography (image cropping). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a image cropping sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The image cropping flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA photography-pixelproof-sharing-18 · Base · PixelProof Sharing =====
Page: https://arcprompts.lovable.app/ideas/photography-pixelproof-sharing-18

Build "PixelProof Sharing" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin watermarked photos and proofs on IPFS to prevent unauthorized reuse with traceable CID.
Discipline: Photography (image watermarking). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a image watermarking sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The image watermarking flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA photography-filterchain-exchange-19 · Base · FilterChain Exchange =====
Page: https://arcprompts.lovable.app/ideas/photography-filterchain-exchange-19

Build "FilterChain Exchange" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Publish photography filters and their sample images pinned on IPFS for permanent decentralized sharing.
Discipline: Photography (filter sharing). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a filter sharing sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The filter sharing flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA photography-storyframe-ledger-20 · Base · StoryFrame Ledger =====
Page: https://arcprompts.lovable.app/ideas/photography-storyframe-ledger-20

Build "StoryFrame Ledger" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin photo-story manifests on IPFS to secure multi-image narratives with permanent provenance.
Discipline: Photography (photo storytelling). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a photo storytelling sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The photo storytelling flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA photography-depthmap-chain-21 · Base · DepthMap Chain =====
Page: https://arcprompts.lovable.app/ideas/photography-depthmap-chain-21

Build "DepthMap Chain" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin depth maps and photos together on IPFS to preserve immersive photo data immutably.
Discipline: Photography (3D photography). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a 3D photography sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The 3D photography flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA photography-framesplit-archive-22 · Base · FrameSplit Archive =====
Page: https://arcprompts.lovable.app/ideas/photography-framesplit-archive-22

Build "FrameSplit Archive" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin segmented photo layers on IPFS for permanent storage and collaborative recombination.
Discipline: Photography (photo segmentation). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a photo segmentation sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The photo segmentation flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA photography-batchpin-manager-23 · Base · BatchPin Manager =====
Page: https://arcprompts.lovable.app/ideas/photography-batchpin-manager-23

Build "BatchPin Manager" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin and manage large photo batches on IPFS with JWT to streamline permanent storage workflows.
Discipline: Photography (bulk image processing). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a bulk image processing sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The bulk image processing flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA photography-mirrorframe-backup-24 · Base · MirrorFrame Backup =====
Page: https://arcprompts.lovable.app/ideas/photography-mirrorframe-backup-24

Build "MirrorFrame Backup" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Create decentralized backups of photos pinned on IPFS to protect against data loss permanently.
Discipline: Photography (image backup). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a image backup sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The image backup flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA photography-gasless-gallery-0 · Base · Gasless Gallery =====
Page: https://arcprompts.lovable.app/ideas/photography-gasless-gallery-0

Build "Gasless Gallery" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Seamlessly share photos onchain with no gas fees for your audience and collaborators.
Discipline: Photography (photo sharing). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a photo sharing action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The photo sharing flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA photography-nft-photo-stories-1 · Base · NFT Photo Stories =====
Page: https://arcprompts.lovable.app/ideas/photography-nft-photo-stories-1

Build "NFT Photo Stories" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Create and share onchain photo stories with built-in provenance and no wallet setup hassle.
Discipline: Photography (photojournalism). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a photojournalism action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The photojournalism flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA photography-chaincolor-study-2 · Base · ChainColor Study =====
Page: https://arcprompts.lovable.app/ideas/photography-chaincolor-study-2

Build "ChainColor Study" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Save and share color grading presets onchain without spending gas or complex wallet setup.
Discipline: Photography (color grading). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a color grading action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The color grading flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA photography-gas-free-prints-order-3 · Base · Gas-Free Prints Order =====
Page: https://arcprompts.lovable.app/ideas/photography-gas-free-prints-order-3

Build "Gas-Free Prints Order" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Order professional photo prints onchain with gasless transactions for instant confirmation.
Discipline: Photography (print ordering). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a print ordering action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The print ordering flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA photography-privy-photo-bounties-4 · Base · Privy Photo Bounties =====
Page: https://arcprompts.lovable.app/ideas/photography-privy-photo-bounties-4

Build "Privy Photo Bounties" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Create gasless, onchain photo curation challenges with built-in rewards and easy entry.
Discipline: Photography (community curation). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a community curation action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The community curation flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA photography-instant-rights-ledger-5 · Base · Instant Rights Ledger =====
Page: https://arcprompts.lovable.app/ideas/photography-instant-rights-ledger-5

Build "Instant Rights Ledger" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Manage photo licensing rights transparently onchain with no gas fees for creators.
Discipline: Photography (rights management). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a rights management action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The rights management flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA photography-gasless-metadata-tags-6 · Base · Gasless Metadata Tags =====
Page: https://arcprompts.lovable.app/ideas/photography-gasless-metadata-tags-6

Build "Gasless Metadata Tags" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Add and sync photo metadata onchain without gas fees or wallet complications.
Discipline: Photography (photo metadata). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a photo metadata action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The photo metadata flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA photography-sponsored-tx-photo-sales-7 · Base · Sponsored Tx Photo Sales =====
Page: https://arcprompts.lovable.app/ideas/photography-sponsored-tx-photo-sales-7

Build "Sponsored Tx Photo Sales" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Sell your photos onchain with gasless transactions for buyers and sellers alike.
Discipline: Photography (photo marketplace). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a photo marketplace action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The photo marketplace flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA photography-privy-nft-experiments-8 · Base · Privy NFT Experiments =====
Page: https://arcprompts.lovable.app/ideas/photography-privy-nft-experiments-8

Build "Privy NFT Experiments" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Easily mint and share photo NFTs with zero-gas user experience via Privy wallets.
Discipline: Photography (photo NFT art). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a photo NFT art action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The photo NFT art flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA photography-gas-free-collaboration-9 · Base · Gas-Free Collaboration =====
Page: https://arcprompts.lovable.app/ideas/photography-gas-free-collaboration-9

Build "Gas-Free Collaboration" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Collaborate on photo edits and shares onchain with zero gas fees for team members.
Discipline: Photography (team workflow). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a team workflow action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The team workflow flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA photography-onchain-event-albums-10 · Base · Onchain Event Albums =====
Page: https://arcprompts.lovable.app/ideas/photography-onchain-event-albums-10

Build "Onchain Event Albums" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Create and distribute event photo albums onchain with no gas fees for attendees.
Discipline: Photography (event photography). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a event photography action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The event photography flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA photography-privy-photo-feedback-11 · Base · Privy Photo Feedback =====
Page: https://arcprompts.lovable.app/ideas/photography-privy-photo-feedback-11

Build "Privy Photo Feedback" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Get instant, onchain photo feedback from peers with sponsored no-gas transactions.
Discipline: Photography (photo critique). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a photo critique action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The photo critique flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA photography-gasless-photo-auctions-12 · Base · Gasless Photo Auctions =====
Page: https://arcprompts.lovable.app/ideas/photography-gasless-photo-auctions-12

Build "Gasless Photo Auctions" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Host and join photo auctions onchain with zero gas fees and simple wallet integration.
Discipline: Photography (photo auctions). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a photo auctions action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The photo auctions flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA photography-chain-stamped-edits-13 · Base · Chain-Stamped Edits =====
Page: https://arcprompts.lovable.app/ideas/photography-chain-stamped-edits-13

Build "Chain-Stamped Edits" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Record photo edit history onchain instantly without needing users to pay gas.
Discipline: Photography (edit provenance). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a edit provenance action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The edit provenance flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA photography-sponsored-tx-model-releases-14 · Base · Sponsored Tx Model Releases =====
Page: https://arcprompts.lovable.app/ideas/photography-sponsored-tx-model-releases-14

Build "Sponsored Tx Model Releases" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Secure photo model releases onchain with gasless transactions for photographers and talent.
Discipline: Photography (legal docs). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a legal docs action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The legal docs flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA photography-onchain-photo-licensing-15 · Base · Onchain Photo Licensing =====
Page: https://arcprompts.lovable.app/ideas/photography-onchain-photo-licensing-15

Build "Onchain Photo Licensing" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Negotiate and finalize photo licenses onchain with no gas fees for quick deals.
Discipline: Photography (rights clearing). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a rights clearing action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The rights clearing flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA photography-gasless-watermark-tags-16 · Base · Gasless Watermark Tags =====
Page: https://arcprompts.lovable.app/ideas/photography-gasless-watermark-tags-16

Build "Gasless Watermark Tags" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Apply and verify photo watermarks onchain without wallet or gas hassles.
Discipline: Photography (copyright protection). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a copyright protection action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The copyright protection flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA photography-privy-photo-assets-17 · Base · Privy Photo Assets =====
Page: https://arcprompts.lovable.app/ideas/photography-privy-photo-assets-17

Build "Privy Photo Assets" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Manage photo assets onchain with no gas fees for easy organization and sharing.
Discipline: Photography (asset management). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a asset management action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The asset management flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA photography-sponsored-tx-photo-tips-18 · Base · Sponsored Tx Photo Tips =====
Page: https://arcprompts.lovable.app/ideas/photography-sponsored-tx-photo-tips-18

Build "Sponsored Tx Photo Tips" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Receive tips for your photography onchain without users paying gas fees.
Discipline: Photography (content monetization). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a content monetization action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The content monetization flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA photography-chain-verified-exif-19 · Base · Chain-Verified EXIF =====
Page: https://arcprompts.lovable.app/ideas/photography-chain-verified-exif-19

Build "Chain-Verified EXIF" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Verify and store immutable EXIF data onchain without wallet or gas barriers.
Discipline: Photography (photo metadata). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a photo metadata action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The photo metadata flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA photography-gasless-photo-badges-20 · Base · Gasless Photo Badges =====
Page: https://arcprompts.lovable.app/ideas/photography-gasless-photo-badges-20

Build "Gasless Photo Badges" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Earn and showcase onchain badges for photography achievements with zero gas fees.
Discipline: Photography (community rewards). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a community rewards action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The community rewards flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA photography-onchain-lens-reviews-21 · Base · Onchain Lens Reviews =====
Page: https://arcprompts.lovable.app/ideas/photography-onchain-lens-reviews-21

Build "Onchain Lens Reviews" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Submit and share authentic lens reviews onchain with no gas required from users.
Discipline: Photography (equipment reviews). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a equipment reviews action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The equipment reviews flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA photography-privy-photo-grants-22 · Base · Privy Photo Grants =====
Page: https://arcprompts.lovable.app/ideas/photography-privy-photo-grants-22

Build "Privy Photo Grants" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Distribute photography project grants onchain with sponsored transactions removing gas costs.
Discipline: Photography (creative funding). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a creative funding action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The creative funding flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA photography-chain-linked-portfolios-23 · Base · Chain-Linked Portfolios =====
Page: https://arcprompts.lovable.app/ideas/photography-chain-linked-portfolios-23

Build "Chain-Linked Portfolios" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Create gasless onchain portfolios linking proofs and metadata automatically.
Discipline: Photography (portfolio management). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a portfolio management action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The portfolio management flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA photography-sponsored-tx-photo-collages-24 · Base · Sponsored Tx Photo Collages =====
Page: https://arcprompts.lovable.app/ideas/photography-sponsored-tx-photo-collages-24

Build "Sponsored Tx Photo Collages" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Build and share photo collages onchain instantly without users paying gas fees.
Discipline: Photography (creative assembly). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a creative assembly action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The creative assembly flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA photography-trueshot-ledger-0 · Base · TrueShot Ledger =====
Page: https://arcprompts.lovable.app/ideas/photography-trueshot-ledger-0

Build "TrueShot Ledger" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Prove original photo ownership to combat unauthorized reuse and forgery.
Discipline: Photography (photo authenticity). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a photo authenticity work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The photo authenticity flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA photography-edittrace-chain-1 · Base · EditTrace Chain =====
Page: https://arcprompts.lovable.app/ideas/photography-edittrace-chain-1

Build "EditTrace Chain" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Track complete edit histories on-chain for transparent creative workflows.
Discipline: Photography (photo editing history). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a photo editing history work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The photo editing history flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA photography-proprint-certify-2 · Base · ProPrint Certify =====
Page: https://arcprompts.lovable.app/ideas/photography-proprint-certify-2

Build "ProPrint Certify" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Certify fine art photo prints with tamper-proof digital provenance.
Discipline: Photography (fine art prints). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a fine art prints work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The fine art prints flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA photography-snapevent-auth-3 · Base · SnapEvent Auth =====
Page: https://arcprompts.lovable.app/ideas/photography-snapevent-auth-3

Build "SnapEvent Auth" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Validate event photo ownership instantly with blockchain timestamps.
Discipline: Photography (event photography). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a event photography work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The event photography flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA photography-newsframe-provenance-4 · Base · NewsFrame Provenance =====
Page: https://arcprompts.lovable.app/ideas/photography-newsframe-provenance-4

Build "NewsFrame Provenance" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Authenticate frontline news photos with immutable creator-owned tokens.
Discipline: Photography (photojournalism). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a photojournalism work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The photojournalism flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA photography-stocksnap-rights-5 · Base · StockSnap Rights =====
Page: https://arcprompts.lovable.app/ideas/photography-stocksnap-rights-5

Build "StockSnap Rights" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Secure and track photo stock licensing with NFT-based ownership proof.
Discipline: Photography (stock photography). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a stock photography work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The stock photography flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA photography-lensstory-archive-6 · Base · LensStory Archive =====
Page: https://arcprompts.lovable.app/ideas/photography-lensstory-archive-6

Build "LensStory Archive" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Create permanent, traceable archives of photo collections on blockchain.
Discipline: Photography (photography archives). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a photography archives work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The photography archives flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA photography-collaboshot-chain-7 · Base · CollaboShot Chain =====
Page: https://arcprompts.lovable.app/ideas/photography-collaboshot-chain-7

Build "CollaboShot Chain" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Securely track multi-photographer project ownership with shared NFTs.
Discipline: Photography (collaborative shoots). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a collaborative shoots work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The collaborative shoots flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA photography-vintagevibe-mint-8 · Base · VintageVibe Mint =====
Page: https://arcprompts.lovable.app/ideas/photography-vintagevibe-mint-8

Build "VintageVibe Mint" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Digitally mint vintage photo scans to preserve original source provenance.
Discipline: Photography (vintage photography). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a vintage photography work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The vintage photography flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA photography-framechain-gallery-9 · Base · FrameChain Gallery =====
Page: https://arcprompts.lovable.app/ideas/photography-framechain-gallery-9

Build "FrameChain Gallery" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Create blockchain-backed digital photo galleries with verified provenance.
Discipline: Photography (digital galleries). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a digital galleries work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The digital galleries flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA photography-focusproof-vault-10 · Base · FocusProof Vault =====
Page: https://arcprompts.lovable.app/ideas/photography-focusproof-vault-10

Build "FocusProof Vault" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Use on-chain minted NFTs as legally admissible photo evidence.
Discipline: Photography (photo legal evidence). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a photo legal evidence work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The photo legal evidence flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA photography-macromint-origins-11 · Base · MacroMint Origins =====
Page: https://arcprompts.lovable.app/ideas/photography-macromint-origins-11

Build "MacroMint Origins" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Authenticate original macro shots with creator-owned NFTs.
Discipline: Photography (macro photography). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a macro photography work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The macro photography flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA photography-timelapse-token-12 · Base · TimeLapse Token =====
Page: https://arcprompts.lovable.app/ideas/photography-timelapse-token-12

Build "TimeLapse Token" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Record and prove time-lapse photo sequences provenance on blockchain.
Discipline: Photography (time-lapse photography). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a time-lapse photography work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The time-lapse photography flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA photography-portraitclaim-chain-13 · Base · PortraitClaim Chain =====
Page: https://arcprompts.lovable.app/ideas/photography-portraitclaim-chain-13

Build "PortraitClaim Chain" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Secure portrait ownership and licensing with NFT provenance minting.
Discipline: Photography (portrait photography). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a portrait photography work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The portrait photography flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA photography-droneshot-ledger-14 · Base · DroneShot Ledger =====
Page: https://arcprompts.lovable.app/ideas/photography-droneshot-ledger-14

Build "DroneShot Ledger" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Track drone photo creations with immutable blockchain provenance.
Discipline: Photography (drone photography). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a drone photography work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The drone photography flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA photography-filtermint-chain-15 · Base · FilterMint Chain =====
Page: https://arcprompts.lovable.app/ideas/photography-filtermint-chain-15

Build "FilterMint Chain" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Prove filter creation and usage history on-chain for unique photo effects.
Discipline: Photography (creative filters). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a creative filters work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The creative filters flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA photography-photostory-token-16 · Base · PhotoStory Token =====
Page: https://arcprompts.lovable.app/ideas/photography-photostory-token-16

Build "PhotoStory Token" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Attach narrative stories securely to photos using NFT provenance.
Discipline: Photography (photo narratives). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a photo narratives work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The photo narratives flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA photography-360proof-chain-17 · Base · 360Proof Chain =====
Page: https://arcprompts.lovable.app/ideas/photography-360proof-chain-17

Build "360Proof Chain" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Authenticate and secure ownership of 360-degree photos on the blockchain.
Discipline: Photography (360° photography). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a 360° photography work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The 360° photography flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA photography-eventsnap-token-18 · Base · EventSnap Token =====
Page: https://arcprompts.lovable.app/ideas/photography-eventsnap-token-18

Build "EventSnap Token" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Guarantee wedding photo originality and ownership with NFT provenance.
Discipline: Photography (wedding photography). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a wedding photography work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The wedding photography flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA photography-colorgrade-chain-19 · Base · ColorGrade Chain =====
Page: https://arcprompts.lovable.app/ideas/photography-colorgrade-chain-19

Build "ColorGrade Chain" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Track and prove original photo color grades and presets on-chain.
Discipline: Photography (color grading). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a color grading work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The color grading flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA photography-wildlifemint-ledger-20 · Base · WildlifeMint Ledger =====
Page: https://arcprompts.lovable.app/ideas/photography-wildlifemint-ledger-20

Build "WildlifeMint Ledger" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Authenticate unique wildlife photos with immutable NFT provenance tokens.
Discipline: Photography (wildlife photography). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a wildlife photography work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The wildlife photography flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA photography-macrofocus-token-21 · Base · MacroFocus Token =====
Page: https://arcprompts.lovable.app/ideas/photography-macrofocus-token-21

Build "MacroFocus Token" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Securely mint and verify product photo assets via on-chain provenance.
Discipline: Photography (product photography). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a product photography work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The product photography flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA photography-photoset-chain-22 · Base · PhotoSet Chain =====
Page: https://arcprompts.lovable.app/ideas/photography-photoset-chain-22

Build "PhotoSet Chain" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Prove ownership and authenticity of curated photo series collections.
Discipline: Photography (photo series). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a photo series work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The photo series flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA photography-urbanview-token-23 · Base · UrbanView Token =====
Page: https://arcprompts.lovable.app/ideas/photography-urbanview-token-23

Build "UrbanView Token" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Authenticate urban scene photos for creators and licensing platforms.
Discipline: Photography (urban photography). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a urban photography work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The urban photography flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA photography-nightshot-mint-24 · Base · NightShot Mint =====
Page: https://arcprompts.lovable.app/ideas/photography-nightshot-mint-24

Build "NightShot Mint" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Secure and verify ownership of night photos with NFT provenance.
Discipline: Photography (night photography). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a night photography work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The night photography flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA writing-verseledger-0 · Base · VerseLedger =====
Page: https://arcprompts.lovable.app/ideas/writing-verseledger-0

Build "VerseLedger" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Securely timestamp and prove original poem authorship on the blockchain to prevent plagiarism.
Discipline: Writing, Poetry & Narrative (poetry archiving). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a poetry archiving item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The poetry archiving flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA writing-narrativevote-1 · Base · NarrativeVote =====
Page: https://arcprompts.lovable.app/ideas/writing-narrativevote-1

Build "NarrativeVote" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Enable readers to vote on story plot directions through blockchain-based decision contracts.
Discipline: Writing, Poetry & Narrative (interactive storytelling). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a interactive storytelling item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The interactive storytelling flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA writing-scriptroyalty-2 · Base · ScriptRoyalty =====
Page: https://arcprompts.lovable.app/ideas/writing-scriptroyalty-2

Build "ScriptRoyalty" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Automate royalty distribution for collaborative screenplays using verified smart contract agreements.
Discipline: Writing, Poetry & Narrative (screenwriting rights). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a screenwriting rights item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The screenwriting rights flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA writing-poetchain-3 · Base · PoetChain =====
Page: https://arcprompts.lovable.app/ideas/writing-poetchain-3

Build "PoetChain" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Facilitate co-authored poems with edit histories securely stored on blockchain for trust.
Discipline: Writing, Poetry & Narrative (collaborative poetry). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a collaborative poetry item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The collaborative poetry flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA writing-plotproof-4 · Base · PlotProof =====
Page: https://arcprompts.lovable.app/ideas/writing-plotproof-4

Build "PlotProof" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Timestamp story drafts to prove originality and track narrative evolution over time.
Discipline: Writing, Poetry & Narrative (story validation). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a story validation item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The story validation flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA writing-verseauction-5 · Base · VerseAuction =====
Page: https://arcprompts.lovable.app/ideas/writing-verseauction-5

Build "VerseAuction" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Sell original poems as verified digital assets with ownership recorded on Ethereum Sepolia.
Discipline: Writing, Poetry & Narrative (poetry marketplace). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a poetry marketplace item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The poetry marketplace flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA writing-narratordao-6 · Base · NarratorDAO =====
Page: https://arcprompts.lovable.app/ideas/writing-narratordao-6

Build "NarratorDAO" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Create decentralized stories collectively owned and governed by contributors via DAO smart contracts.
Discipline: Writing, Poetry & Narrative (community storytelling). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a community storytelling item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The community storytelling flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA writing-scenemint-7 · Base · SceneMint =====
Page: https://arcprompts.lovable.app/ideas/writing-scenemint-7

Build "SceneMint" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint individual screenplay scenes as NFTs to license or sell specific script parts securely.
Discipline: Writing, Poetry & Narrative (script segments). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a script segments item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The script segments flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA writing-metapoem-8 · Base · MetaPoem =====
Page: https://arcprompts.lovable.app/ideas/writing-metapoem-8

Build "MetaPoem" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Create poems that evolve via blockchain triggers based on reader interactions or events.
Discipline: Writing, Poetry & Narrative (dynamic poetry). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a dynamic poetry item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The dynamic poetry flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA writing-authorshipchain-9 · Base · AuthorshipChain =====
Page: https://arcprompts.lovable.app/ideas/writing-authorshipchain-9

Build "AuthorshipChain" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Manage and verify author identities and pseudonyms securely through smart contract registries.
Discipline: Writing, Poetry & Narrative (writer identity). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a writer identity item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The writer identity flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA writing-plottoken-10 · Base · PlotToken =====
Page: https://arcprompts.lovable.app/ideas/writing-plottoken-10

Build "PlotToken" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Tokenize plot ideas for secure licensing and transfer to producers or collaborators.
Discipline: Writing, Poetry & Narrative (story licensing). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a story licensing item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The story licensing flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA writing-scriptchainaudit-11 · Base · ScriptChainAudit =====
Page: https://arcprompts.lovable.app/ideas/writing-scriptchainaudit-11

Build "ScriptChainAudit" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Track and audit screenplay versions with immutable blockchain timestamps for dispute resolution.
Discipline: Writing, Poetry & Narrative (version tracking). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a version tracking item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The version tracking flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA writing-freeversedao-12 · Base · FreeVerseDAO =====
Page: https://arcprompts.lovable.app/ideas/writing-freeversedao-12

Build "FreeVerseDAO" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Enable decentralized funding and grant distribution for poets via DAO governance onchain.
Discipline: Writing, Poetry & Narrative (poetry funding). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a poetry funding item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The poetry funding flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA writing-narrativebadge-13 · Base · NarrativeBadge =====
Page: https://arcprompts.lovable.app/ideas/writing-narrativebadge-13

Build "NarrativeBadge" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Issue verifiable badges or certificates on Sepolia to recognize narrative design skills and achievements.
Discipline: Writing, Poetry & Narrative (writer credentials). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a writer credentials item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The writer credentials flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA writing-poemchainprint-14 · Base · PoemChainPrint =====
Page: https://arcprompts.lovable.app/ideas/writing-poemchainprint-14

Build "PoemChainPrint" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Create blockchain-verified limited edition poem prints with provable scarcity for collectors.
Discipline: Writing, Poetry & Narrative (limited edition poetry). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a limited edition poetry item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The limited edition poetry flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA writing-narrativestake-15 · Base · NarrativeStake =====
Page: https://arcprompts.lovable.app/ideas/writing-narrativestake-15

Build "NarrativeStake" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Reward story contributors fairly by staking tokens linked to their contributions recorded onchain.
Discipline: Writing, Poetry & Narrative (story contributor rewards). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a story contributor rewards item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The story contributor rewards flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA writing-scriptvote-16 · Base · ScriptVote =====
Page: https://arcprompts.lovable.app/ideas/writing-scriptvote-16

Build "ScriptVote" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Collect and manage anonymous peer feedback on screenplays via secure onchain voting.
Discipline: Writing, Poetry & Narrative (script feedback). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a script feedback item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The script feedback flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA writing-poetryescrow-17 · Base · PoetryEscrow =====
Page: https://arcprompts.lovable.app/ideas/writing-poetryescrow-17

Build "PoetryEscrow" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Hold commissioned poem payments in escrow smart contracts until writer delivers and buyer approves.
Discipline: Writing, Poetry & Narrative (commissioned writing). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a commissioned writing item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The commissioned writing flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA writing-characternft-18 · Base · CharacterNFT =====
Page: https://arcprompts.lovable.app/ideas/writing-characternft-18

Build "CharacterNFT" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Create NFTs representing unique narrative characters to securely license and track derivative use.
Discipline: Writing, Poetry & Narrative (narrative IP). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a narrative IP item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The narrative IP flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA writing-dialoguedao-19 · Base · DialogueDAO =====
Page: https://arcprompts.lovable.app/ideas/writing-dialoguedao-19

Build "DialogueDAO" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Govern and reward co-writers contributing dialogue lines via blockchain DAO mechanisms.
Discipline: Writing, Poetry & Narrative (script collaboration). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a script collaboration item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The script collaboration flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA writing-poetproofs-20 · Base · PoetProofs =====
Page: https://arcprompts.lovable.app/ideas/writing-poetproofs-20

Build "PoetProofs" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Notarize poem drafts with blockchain timestamps to establish authorship and protect IP rights.
Discipline: Writing, Poetry & Narrative (draft notarization). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a draft notarization item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The draft notarization flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA writing-plotchainswap-21 · Base · PlotChainSwap =====
Page: https://arcprompts.lovable.app/ideas/writing-plotchainswap-21

Build "PlotChainSwap" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Enable decentralized swapping and barter of plot ideas secured and logged on blockchain.
Discipline: Writing, Poetry & Narrative (story idea exchange). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a story idea exchange item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The story idea exchange flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA writing-narrativemint-22 · Base · NarrativeMint =====
Page: https://arcprompts.lovable.app/ideas/writing-narrativemint-22

Build "NarrativeMint" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint entire stories as tokens allowing ownership proof and fractional sales.
Discipline: Writing, Poetry & Narrative (story tokenization). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a story tokenization item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The story tokenization flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA writing-screenplaystake-23 · Base · ScreenplayStake =====
Page: https://arcprompts.lovable.app/ideas/writing-screenplaystake-23

Build "ScreenplayStake" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Community members stake tokens to review scripts securely, incentivizing quality feedback.
Discipline: Writing, Poetry & Narrative (crowd script reviewing). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a crowd script reviewing item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The crowd script reviewing flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA writing-poetrychaingift-24 · Base · PoetryChainGift =====
Page: https://arcprompts.lovable.app/ideas/writing-poetrychaingift-24

Build "PoetryChainGift" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Gift poems securely onchain with immutable ownership and personalized provenance records.
Discipline: Writing, Poetry & Narrative (secure gifting). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a secure gifting item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The secure gifting flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA writing-poetic-memory-vault-0 · Base · Poetic Memory Vault =====
Page: https://arcprompts.lovable.app/ideas/writing-poetic-memory-vault-0

Build "Poetic Memory Vault" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Permanently preserve poets' drafts and revisions for authentic literary heritage.
Discipline: Writing, Poetry & Narrative (poetry archiving). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a poetry archiving sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The poetry archiving flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA writing-narrative-flow-sync-1 · Base · Narrative Flow Sync =====
Page: https://arcprompts.lovable.app/ideas/writing-narrative-flow-sync-1

Build "Narrative Flow Sync" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Save and share branching story manifests guaranteeing permanent access and collaboration.
Discipline: Writing, Poetry & Narrative (interactive storytelling). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a interactive storytelling sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The interactive storytelling flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA writing-character-bios-hub-2 · Base · Character Bios Hub =====
Page: https://arcprompts.lovable.app/ideas/writing-character-bios-hub-2

Build "Character Bios Hub" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Store and distribute rich, immutable character profiles with multimedia attachments.
Discipline: Writing, Poetry & Narrative (character development). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a character development sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The character development flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA writing-verse-visualizer-3 · Base · Verse Visualizer =====
Page: https://arcprompts.lovable.app/ideas/writing-verse-visualizer-3

Build "Verse Visualizer" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Upload and preserve poetic image metaphors linked to verse for lasting inspiration.
Discipline: Writing, Poetry & Narrative (poetical imagery). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a poetical imagery sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The poetical imagery flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA writing-screenplay-snapshot-4 · Base · Screenplay Snapshot =====
Page: https://arcprompts.lovable.app/ideas/writing-screenplay-snapshot-4

Build "Screenplay Snapshot" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin your screenplay drafts with visual and metadata snapshots for secure historic reference.
Discipline: Writing, Poetry & Narrative (screenwriting versioning). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a screenwriting versioning sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The screenwriting versioning flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA writing-narrative-map-archive-5 · Base · Narrative Map Archive =====
Page: https://arcprompts.lovable.app/ideas/writing-narrative-map-archive-5

Build "Narrative Map Archive" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Securely store interactive narrative maps and their changes for narrative design teams.
Discipline: Writing, Poetry & Narrative (story mapping). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a story mapping sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The story mapping flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA writing-writer-s-prompt-vault-6 · Base · Writer’s Prompt Vault =====
Page: https://arcprompts.lovable.app/ideas/writing-writer-s-prompt-vault-6

Build "Writer’s Prompt Vault" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Curate and preserve evolving writing prompts and challenges with immutable timestamps.
Discipline: Writing, Poetry & Narrative (creative prompts). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a creative prompts sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The creative prompts flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA writing-narrative-token-ledger-7 · Base · Narrative Token Ledger =====
Page: https://arcprompts.lovable.app/ideas/writing-narrative-token-ledger-7

Build "Narrative Token Ledger" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Register and prove narrative intellectual property rights with permanent onchain manifests.
Discipline: Writing, Poetry & Narrative (story ownership). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a story ownership sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The story ownership flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA writing-poem-remix-repository-8 · Base · Poem Remix Repository =====
Page: https://arcprompts.lovable.app/ideas/writing-poem-remix-repository-8

Build "Poem Remix Repository" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Host and pin collaborative poem remixes with full version history on decentralized storage.
Discipline: Writing, Poetry & Narrative (poetry collaboration). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a poetry collaboration sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The poetry collaboration flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA writing-screenplay-beatboard-9 · Base · Screenplay Beatboard =====
Page: https://arcprompts.lovable.app/ideas/writing-screenplay-beatboard-9

Build "Screenplay Beatboard" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin structured screenplay beatboards and revisions immutably to maintain story consistency.
Discipline: Writing, Poetry & Narrative (plot structuring). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a plot structuring sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The plot structuring flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA writing-narrative-soundtrack-archive-10 · Base · Narrative Soundtrack Archive =====
Page: https://arcprompts.lovable.app/ideas/writing-narrative-soundtrack-archive-10

Build "Narrative Soundtrack Archive" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Store narrative audio clips and story-related soundtracks permanently linked to story manifests.
Discipline: Writing, Poetry & Narrative (audio storytelling). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a audio storytelling sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The audio storytelling flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA writing-metadata-story-weave-11 · Base · Metadata Story Weave =====
Page: https://arcprompts.lovable.app/ideas/writing-metadata-story-weave-11

Build "Metadata Story Weave" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Attach and pin rich metadata sets to stories ensuring permanent discoverability and context.
Discipline: Writing, Poetry & Narrative (story metadata management). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a story metadata management sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The story metadata management flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA writing-epic-poem-archive-12 · Base · Epic Poem Archive =====
Page: https://arcprompts.lovable.app/ideas/writing-epic-poem-archive-12

Build "Epic Poem Archive" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Host epic poems and iterations permanently ensuring literary longevity and accessibility.
Discipline: Writing, Poetry & Narrative (long-form poetry). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a long-form poetry sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The long-form poetry flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA writing-flash-fiction-cache-13 · Base · Flash Fiction Cache =====
Page: https://arcprompts.lovable.app/ideas/writing-flash-fiction-cache-13

Build "Flash Fiction Cache" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin flash fiction and micro-narratives ensuring permanent public access and author credit.
Discipline: Writing, Poetry & Narrative (short story publishing). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a short story publishing sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The short story publishing flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA writing-collaborative-verse-chain-14 · Base · Collaborative Verse Chain =====
Page: https://arcprompts.lovable.app/ideas/writing-collaborative-verse-chain-14

Build "Collaborative Verse Chain" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Immutable shared poetry projects pinned with full authorship and version control.
Discipline: Writing, Poetry & Narrative (co-written poetry). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a co-written poetry sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The co-written poetry flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA writing-narrative-artifact-ledger-15 · Base · Narrative Artifact Ledger =====
Page: https://arcprompts.lovable.app/ideas/writing-narrative-artifact-ledger-15

Build "Narrative Artifact Ledger" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Preserve story artifacts, lore entries and related media immutably linked to narratives.
Discipline: Writing, Poetry & Narrative (story props and lore). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a story props and lore sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The story props and lore flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA writing-writer-s-journal-vault-16 · Base · Writer’s Journal Vault =====
Page: https://arcprompts.lovable.app/ideas/writing-writer-s-journal-vault-16

Build "Writer’s Journal Vault" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin personal writing journals and progress snapshots for secure, permanent archival.
Discipline: Writing, Poetry & Narrative (personal writing logs). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a personal writing logs sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The personal writing logs flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA writing-screenplay-casting-files-17 · Base · Screenplay Casting Files =====
Page: https://arcprompts.lovable.app/ideas/writing-screenplay-casting-files-17

Build "Screenplay Casting Files" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin casting notes and character references permanently linked to screenplay projects.
Discipline: Writing, Poetry & Narrative (casting and character assets). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a casting and character assets sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The casting and character assets flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA writing-narrative-role-tracker-18 · Base · Narrative Role Tracker =====
Page: https://arcprompts.lovable.app/ideas/writing-narrative-role-tracker-18

Build "Narrative Role Tracker" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Immutable tracking of story roles and character arcs pinned for collaborative clarity.
Discipline: Writing, Poetry & Narrative (role-based story design). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a role-based story design sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The role-based story design flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA writing-poetry-event-ledger-19 · Base · Poetry Event Ledger =====
Page: https://arcprompts.lovable.app/ideas/writing-poetry-event-ledger-19

Build "Poetry Event Ledger" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin event schedules, recordings and poems from live readings for lasting access.
Discipline: Writing, Poetry & Narrative (live poetry events). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a live poetry events sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The live poetry events flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA writing-narrative-device-index-20 · Base · Narrative Device Index =====
Page: https://arcprompts.lovable.app/ideas/writing-narrative-device-index-20

Build "Narrative Device Index" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Create permanent indexes of literary devices used in stories with examples and annotations.
Discipline: Writing, Poetry & Narrative (literary device cataloging). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a literary device cataloging sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The literary device cataloging flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA writing-crowdwritten-saga-21 · Base · Crowdwritten Saga =====
Page: https://arcprompts.lovable.app/ideas/writing-crowdwritten-saga-21

Build "Crowdwritten Saga" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin evolving crowd-sourced story manifests for shared narrative ownership and history.
Discipline: Writing, Poetry & Narrative (crowdsourced storytelling). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a crowdsourced storytelling sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The crowdsourced storytelling flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA writing-script-location-scouting-22 · Base · Script Location Scouting =====
Page: https://arcprompts.lovable.app/ideas/writing-script-location-scouting-22

Build "Script Location Scouting" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin images and notes of real locations linked to screenplay scenes immutably.
Discipline: Writing, Poetry & Narrative (visual storytelling assets). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a visual storytelling assets sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The visual storytelling assets flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA writing-story-genre-taxonomy-23 · Base · Story Genre Taxonomy =====
Page: https://arcprompts.lovable.app/ideas/writing-story-genre-taxonomy-23

Build "Story Genre Taxonomy" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin permanent genre taxonomies and story type metadata for consistent classification.
Discipline: Writing, Poetry & Narrative (genre classification). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a genre classification sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The genre classification flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA writing-narrative-timeline-archive-24 · Base · Narrative Timeline Archive =====
Page: https://arcprompts.lovable.app/ideas/writing-narrative-timeline-archive-24

Build "Narrative Timeline Archive" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin chronological story timelines with events and character arcs permanently stored.
Discipline: Writing, Poetry & Narrative (chronology management). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a chronology management sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The chronology management flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA writing-versevault-0 · Base · VerseVault =====
Page: https://arcprompts.lovable.app/ideas/writing-versevault-0

Build "VerseVault" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Securely draft and store poems with seamless gasless transaction experience.
Discipline: Writing, Poetry & Narrative (poetry drafting). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a poetry drafting action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The poetry drafting flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA writing-storystake-1 · Base · StoryStake =====
Page: https://arcprompts.lovable.app/ideas/writing-storystake-1

Build "StoryStake" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Engage writers in creating branching stories with frictionless onchain ownership of choices.
Discipline: Writing, Poetry & Narrative (interactive narrative). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a interactive narrative action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The interactive narrative flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA writing-scriptsponsor-2 · Base · ScriptSponsor =====
Page: https://arcprompts.lovable.app/ideas/writing-scriptsponsor-2

Build "ScriptSponsor" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Collaborate on scripts with transparent, gasless edits tracked via embedded wallets.
Discipline: Writing, Poetry & Narrative (screenwriting collaboration). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a screenwriting collaboration action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The screenwriting collaboration flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA writing-narratenexus-3 · Base · NarrateNexus =====
Page: https://arcprompts.lovable.app/ideas/writing-narratenexus-3

Build "NarrateNexus" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Create and monetize narrative assets securely with seamless wallet integration and no fees.
Discipline: Writing, Poetry & Narrative (narrative design). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a narrative design action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The narrative design flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA writing-poemproof-4 · Base · PoemProof =====
Page: https://arcprompts.lovable.app/ideas/writing-poemproof-4

Build "PoemProof" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Instantly timestamp poems with zero gas to prove authorship and originality.
Discipline: Writing, Poetry & Narrative (poetry copyright). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a poetry copyright action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The poetry copyright flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA writing-versevoyage-5 · Base · VerseVoyage =====
Page: https://arcprompts.lovable.app/ideas/writing-versevoyage-5

Build "VerseVoyage" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Host and join gasless onchain poetry contests with social verification and prizes.
Discipline: Writing, Poetry & Narrative (poetry contests). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a poetry contests action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The poetry contests flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA writing-fictionfuel-6 · Base · FictionFuel =====
Page: https://arcprompts.lovable.app/ideas/writing-fictionfuel-6

Build "FictionFuel" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Collaborate on story ideas privately with gasless transactions to ensure smooth feedback flow.
Discipline: Writing, Poetry & Narrative (story ideation). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a story ideation action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The story ideation flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA writing-scriptsync-7 · Base · ScriptSync =====
Page: https://arcprompts.lovable.app/ideas/writing-scriptsync-7

Build "ScriptSync" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Version screenplays with transparent, sponsored blockchain transactions for seamless updates.
Discipline: Writing, Poetry & Narrative (screenplay versioning). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a screenplay versioning action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The screenplay versioning flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA writing-narrativenest-8 · Base · NarrativeNest =====
Page: https://arcprompts.lovable.app/ideas/writing-narrativenest-8

Build "NarrativeNest" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Build and own expansive world lore collaboratively with gasless onchain edits and storage.
Discipline: Writing, Poetry & Narrative (world-building). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a world-building action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The world-building flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA writing-versevouch-9 · Base · VerseVouch =====
Page: https://arcprompts.lovable.app/ideas/writing-versevouch-9

Build "VerseVouch" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Endorse favorite poems effortlessly with gasless transactions linked to your social identity.
Discipline: Writing, Poetry & Narrative (poetry endorsement). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a poetry endorsement action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The poetry endorsement flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA writing-plotpledge-10 · Base · PlotPledge =====
Page: https://arcprompts.lovable.app/ideas/writing-plotpledge-10

Build "PlotPledge" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pledge funds to promising stories with seamless, gasless blockchain sponsorship wallets.
Discipline: Writing, Poetry & Narrative (crowdfund writing). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a crowdfund writing action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The crowdfund writing flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA writing-narratenft-11 · Base · NarrateNFT =====
Page: https://arcprompts.lovable.app/ideas/writing-narratenft-11

Build "NarrateNFT" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint story elements as NFTs with embedded, gasless wallet integration for easy ownership.
Discipline: Writing, Poetry & Narrative (narrative NFTs). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a narrative NFTs action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The narrative NFTs flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA writing-scriptsponsorswap-12 · Base · ScriptSponsorSwap =====
Page: https://arcprompts.lovable.app/ideas/writing-scriptsponsorswap-12

Build "ScriptSponsorSwap" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Enable patrons to sponsor screenwriters with gasless, secure onchain wallet transactions.
Discipline: Writing, Poetry & Narrative (screenwriter patronage). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a screenwriter patronage action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The screenwriter patronage flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA writing-versevaultlive-13 · Base · VerseVaultLive =====
Page: https://arcprompts.lovable.app/ideas/writing-versevaultlive-13

Build "VerseVaultLive" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Host live poetry writing sessions with instant, gasless collaborative edits and social interaction.
Discipline: Writing, Poetry & Narrative (live poetry). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a live poetry action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The live poetry flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA writing-narrativenodes-14 · Base · NarrativeNodes =====
Page: https://arcprompts.lovable.app/ideas/writing-narrativenodes-14

Build "NarrativeNodes" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Design interconnected story graphs collaboratively with frictionless onchain edits and ownership.
Discipline: Writing, Poetry & Narrative (story graph design). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a story graph design action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The story graph design flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA writing-echoedit-15 · Base · EchoEdit =====
Page: https://arcprompts.lovable.app/ideas/writing-echoedit-15

Build "EchoEdit" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Exchange onchain peer critiques with gasless transactions tied to verified social identities.
Discipline: Writing, Poetry & Narrative (peer feedback). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a peer feedback action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The peer feedback flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA writing-plotpassport-16 · Base · PlotPassport =====
Page: https://arcprompts.lovable.app/ideas/writing-plotpassport-16

Build "PlotPassport" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Securely register story beginnings onchain with gasless wallet transactions for easy proof.
Discipline: Writing, Poetry & Narrative (story ownership). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a story ownership action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The story ownership flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA writing-versevibe-17 · Base · VerseVibe =====
Page: https://arcprompts.lovable.app/ideas/writing-versevibe-17

Build "VerseVibe" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Share and tip poems in a gasless, social wallet environment to build fan engagement.
Discipline: Writing, Poetry & Narrative (poetry social feed). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a poetry social feed action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The poetry social feed flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA writing-scriptstand-18 · Base · ScriptStand =====
Page: https://arcprompts.lovable.app/ideas/writing-scriptstand-18

Build "ScriptStand" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Buy and sell scripts with frictionless, gasless onchain payments linked to social wallets.
Discipline: Writing, Poetry & Narrative (script marketplace). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a script marketplace action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The script marketplace flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA writing-storysprint-19 · Base · StorySprint =====
Page: https://arcprompts.lovable.app/ideas/writing-storysprint-19

Build "StorySprint" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Participate in timed story challenges with instant, gasless onchain submissions and social proof.
Discipline: Writing, Poetry & Narrative (timed writing). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a timed writing action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The timed writing flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA writing-echoessays-20 · Base · EchoEssays =====
Page: https://arcprompts.lovable.app/ideas/writing-echoessays-20

Build "EchoEssays" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Publish and securely timestamp essays with gasless wallet transactions for provenance.
Discipline: Writing, Poetry & Narrative (narrative essays). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a narrative essays action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The narrative essays flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA writing-versevest-21 · Base · VerseVest =====
Page: https://arcprompts.lovable.app/ideas/writing-versevest-21

Build "VerseVest" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Manage and distribute poetry royalties transparently via gasless blockchain transactions.
Discipline: Writing, Poetry & Narrative (poetry royalties). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a poetry royalties action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The poetry royalties flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA writing-narratenestnft-22 · Base · NarrateNestNFT =====
Page: https://arcprompts.lovable.app/ideas/writing-narratenestnft-22

Build "NarrateNestNFT" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint and trade world-building NFTs with seamless, gasless wallet integration.
Discipline: Writing, Poetry & Narrative (world-building NFTs). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a world-building NFTs action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The world-building NFTs flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA writing-plotpulse-23 · Base · PlotPulse =====
Page: https://arcprompts.lovable.app/ideas/writing-plotpulse-23

Build "PlotPulse" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Analyze reader engagement on stories with gasless onchain interaction tracking.
Discipline: Writing, Poetry & Narrative (story analytics). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a story analytics action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The story analytics flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA writing-scriptsphere-24 · Base · ScriptSphere =====
Page: https://arcprompts.lovable.app/ideas/writing-scriptsphere-24

Build "ScriptSphere" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Share scripts for peer review with gasless, onchain social wallet transactions.
Discipline: Writing, Poetry & Narrative (script feedback). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a script feedback action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The script feedback flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA writing-verse-vault-0 · Base · Verse Vault =====
Page: https://arcprompts.lovable.app/ideas/writing-verse-vault-0

Build "Verse Vault" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Securely mint and prove ownership of original poetry on-chain for authentic literary legacy.
Discipline: Writing, Poetry & Narrative (poetry archiving). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a poetry archiving work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The poetry archiving flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA writing-narrative-nexus-1 · Base · Narrative Nexus =====
Page: https://arcprompts.lovable.app/ideas/writing-narrative-nexus-1

Build "Narrative Nexus" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint branching story nodes as NFTs to ensure unique creator control and provenance.
Discipline: Writing, Poetry & Narrative (interactive storytelling). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a interactive storytelling work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The interactive storytelling flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA writing-script-stamp-2 · Base · Script Stamp =====
Page: https://arcprompts.lovable.app/ideas/writing-script-stamp-2

Build "Script Stamp" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint screenplay drafts as NFTs to certify original authorship and version history.
Discipline: Writing, Poetry & Narrative (screenwriting rights). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a screenwriting rights work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The screenwriting rights flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA writing-poet-s-provenance-3 · Base · Poet’s Provenance =====
Page: https://arcprompts.lovable.app/ideas/writing-poet-s-provenance-3

Build "Poet’s Provenance" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Create unique NFT tokens for lyric poems, certifying creators and preserving provenance.
Discipline: Writing, Poetry & Narrative (lyric poetry). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a lyric poetry work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The lyric poetry flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA writing-fable-frame-4 · Base · Fable Frame =====
Page: https://arcprompts.lovable.app/ideas/writing-fable-frame-4

Build "Fable Frame" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint children’s story drafts as NFTs to track authorship and distribution rights.
Discipline: Writing, Poetry & Narrative (children’s narratives). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a children’s narratives work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The children’s narratives flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA writing-epic-editions-5 · Base · Epic Editions =====
Page: https://arcprompts.lovable.app/ideas/writing-epic-editions-5

Build "Epic Editions" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint chapters of novels as NFTs to prove authorship and track unpublished drafts.
Discipline: Writing, Poetry & Narrative (long-form fiction). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a long-form fiction work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The long-form fiction flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA writing-freeverse-forge-6 · Base · Freeverse Forge =====
Page: https://arcprompts.lovable.app/ideas/writing-freeverse-forge-6

Build "Freeverse Forge" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint free verse poems as creator-owned NFTs with guaranteed provenance and originality.
Discipline: Writing, Poetry & Narrative (experimental poetry). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a experimental poetry work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The experimental poetry flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA writing-dialogue-drop-7 · Base · Dialogue Drop =====
Page: https://arcprompts.lovable.app/ideas/writing-dialogue-drop-7

Build "Dialogue Drop" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint dialogues as NFTs to certify creation and facilitate transparent rights management.
Discipline: Writing, Poetry & Narrative (scriptwriting dialogue). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a scriptwriting dialogue work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The scriptwriting dialogue flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA writing-mythos-mint-8 · Base · Mythos Mint =====
Page: https://arcprompts.lovable.app/ideas/writing-mythos-mint-8

Build "Mythos Mint" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint lore pieces as NFTs to secure original world-building content and creator identity.
Discipline: Writing, Poetry & Narrative (world-building lore). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a world-building lore work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The world-building lore flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA writing-sonnet-seal-9 · Base · Sonnet Seal =====
Page: https://arcprompts.lovable.app/ideas/writing-sonnet-seal-9

Build "Sonnet Seal" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint sonnets as NFTs to certify original poetic works and preserve ownership rights.
Discipline: Writing, Poetry & Narrative (classic poetry). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a classic poetry work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The classic poetry flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA writing-plotpoint-proof-10 · Base · PlotPoint Proof =====
Page: https://arcprompts.lovable.app/ideas/writing-plotpoint-proof-10

Build "PlotPoint Proof" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint plot outlines as NFTs to prove original story structures and creator authorship.
Discipline: Writing, Poetry & Narrative (story plotting). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a story plotting work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The story plotting flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA writing-haiku-hub-11 · Base · Haiku Hub =====
Page: https://arcprompts.lovable.app/ideas/writing-haiku-hub-11

Build "Haiku Hub" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint haiku poems as unique NFTs to secure authorship with decentralized verification.
Discipline: Writing, Poetry & Narrative (micro-poetry). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a micro-poetry work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The micro-poetry flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA writing-scriptsync-12 · Base · ScriptSync =====
Page: https://arcprompts.lovable.app/ideas/writing-scriptsync-12

Build "ScriptSync" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint collaborative screenplay segments as NFTs to prove multi-author ownership securely.
Discipline: Writing, Poetry & Narrative (collaborative scripts). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a collaborative scripts work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The collaborative scripts flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA writing-prose-provenance-13 · Base · Prose Provenance =====
Page: https://arcprompts.lovable.app/ideas/writing-prose-provenance-13

Build "Prose Provenance" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint short stories as NFTs to validate originality and protect author rights.
Discipline: Writing, Poetry & Narrative (short story writing). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a short story writing work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The short story writing flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA writing-memoir-mint-14 · Base · Memoir Mint =====
Page: https://arcprompts.lovable.app/ideas/writing-memoir-mint-14

Build "Memoir Mint" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint memoir excerpts as NFTs to preserve authentic creator ownership and history.
Discipline: Writing, Poetry & Narrative (personal narratives). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a personal narratives work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The personal narratives flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA writing-lyric-link-15 · Base · Lyric Link =====
Page: https://arcprompts.lovable.app/ideas/writing-lyric-link-15

Build "Lyric Link" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint song lyrics as NFTs to certify authorship and protect intellectual property.
Discipline: Writing, Poetry & Narrative (songwriting lyrics). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a songwriting lyrics work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The songwriting lyrics flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA writing-narrator-s-nod-16 · Base · Narrator’s Nod =====
Page: https://arcprompts.lovable.app/ideas/writing-narrator-s-nod-16

Build "Narrator’s Nod" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint audiobook scripts as NFTs to prove original authorship and distribution rights.
Discipline: Writing, Poetry & Narrative (audiobook scripts). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a audiobook scripts work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The audiobook scripts flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA writing-plot-mint-17 · Base · Plot Mint =====
Page: https://arcprompts.lovable.app/ideas/writing-plot-mint-17

Build "Plot Mint" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint story concepts as NFTs to validate originality and stake creative claims.
Discipline: Writing, Poetry & Narrative (story idea validation). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a story idea validation work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The story idea validation flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA writing-epic-endorse-18 · Base · Epic Endorse =====
Page: https://arcprompts.lovable.app/ideas/writing-epic-endorse-18

Build "Epic Endorse" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint peer review notes as NFTs to transparently acknowledge contributions to works.
Discipline: Writing, Poetry & Narrative (literary peer review). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a literary peer review work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The literary peer review flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA writing-narrative-nexus-19 · Base · Narrative Nexus =====
Page: https://arcprompts.lovable.app/ideas/writing-narrative-nexus-19

Build "Narrative Nexus" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint branching game story elements as NFTs to track creators and version history.
Discipline: Writing, Poetry & Narrative (game narrative design). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a game narrative design work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The game narrative design flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA writing-poetprints-20 · Base · PoetPrints =====
Page: https://arcprompts.lovable.app/ideas/writing-poetprints-20

Build "PoetPrints" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint poetic works as NFTs to facilitate transparent licensing and royalty tracking.
Discipline: Writing, Poetry & Narrative (poetry licensing). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a poetry licensing work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The poetry licensing flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA writing-dialogue-dao-21 · Base · Dialogue DAO =====
Page: https://arcprompts.lovable.app/ideas/writing-dialogue-dao-21

Build "Dialogue DAO" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint dialogue NFTs for decentralized collaboration with verified authorship.
Discipline: Writing, Poetry & Narrative (scriptwriting collaboration). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a scriptwriting collaboration work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The scriptwriting collaboration flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA writing-musemint-22 · Base · MuseMint =====
Page: https://arcprompts.lovable.app/ideas/writing-musemint-22

Build "MuseMint" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint prompt NFTs to claim originality and track prompt provenance for writers.
Discipline: Writing, Poetry & Narrative (creative prompts). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a creative prompts work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The creative prompts flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA writing-fiction-flow-23 · Base · Fiction Flow =====
Page: https://arcprompts.lovable.app/ideas/writing-fiction-flow-23

Build "Fiction Flow" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint serialized fiction episodes as NFTs to prove originality and ownership over time.
Discipline: Writing, Poetry & Narrative (serialized fiction). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a serialized fiction work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The serialized fiction flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA writing-verse-vault-24 · Base · Verse Vault =====
Page: https://arcprompts.lovable.app/ideas/writing-verse-vault-24

Build "Verse Vault" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint spoken word performances as NFTs to certify creator and preserve provenance.
Discipline: Writing, Poetry & Narrative (spoken word poetry). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a spoken word poetry work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The spoken word poetry flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA film-animation-framechain-ledger-0 · Base · FrameChain Ledger =====
Page: https://arcprompts.lovable.app/ideas/film-animation-framechain-ledger-0

Build "FrameChain Ledger" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Verify animation frames' originality and authorship on an immutable blockchain ledger.
Discipline: Filmmaking & Animation (frame provenance). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a frame provenance item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The frame provenance flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA film-animation-scriptmint-1 · Base · ScriptMint =====
Page: https://arcprompts.lovable.app/ideas/film-animation-scriptmint-1

Build "ScriptMint" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Track and transfer screenplay rights securely through blockchain for transparent ownership history.
Discipline: Filmmaking & Animation (script rights tracking). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a script rights tracking item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The script rights tracking flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA film-animation-animstake-voting-2 · Base · AnimStake Voting =====
Page: https://arcprompts.lovable.app/ideas/film-animation-animstake-voting-2

Build "AnimStake Voting" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Enable decentralized community voting to fund independent animations using secure onchain ballots.
Discipline: Filmmaking & Animation (crowd animation funding). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a crowd animation funding item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The crowd animation funding flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA film-animation-motionnft-vault-3 · Base · MotionNFT Vault =====
Page: https://arcprompts.lovable.app/ideas/film-animation-motionnft-vault-3

Build "MotionNFT Vault" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint and trade unique motion design assets as NFTs with verifiable ownership and licensing.
Discipline: Filmmaking & Animation (motion asset NFTs). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a motion asset NFTs item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The motion asset NFTs flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA film-animation-storyboardchain-4 · Base · StoryboardChain =====
Page: https://arcprompts.lovable.app/ideas/film-animation-storyboardchain-4

Build "StoryboardChain" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Record storyboard versions onchain to prove originality and evolution of narrative visuals.
Discipline: Filmmaking & Animation (storyboard authenticity). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a storyboard authenticity item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The storyboard authenticity flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA film-animation-licenselock-5 · Base · LicenseLock =====
Page: https://arcprompts.lovable.app/ideas/film-animation-licenselock-5

Build "LicenseLock" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Manage animation asset licenses securely and transparently on a blockchain smart contract.
Discipline: Filmmaking & Animation (license management). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a license management item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The license management flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA film-animation-animcred-score-6 · Base · AnimCred Score =====
Page: https://arcprompts.lovable.app/ideas/film-animation-animcred-score-6

Build "AnimCred Score" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Build transparent, verifiable reputation scores for filmmakers and animators using onchain activity.
Discipline: Filmmaking & Animation (creator reputation). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a creator reputation item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The creator reputation flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA film-animation-sceneswap-dex-7 · Base · SceneSwap DEX =====
Page: https://arcprompts.lovable.app/ideas/film-animation-sceneswap-dex-7

Build "SceneSwap DEX" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Trade and swap 3D scenes and animation assets peer-to-peer with secure onchain escrow.
Discipline: Filmmaking & Animation (asset exchange). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a asset exchange item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The asset exchange flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA film-animation-animguild-dao-8 · Base · AnimGuild DAO =====
Page: https://arcprompts.lovable.app/ideas/film-animation-animguild-dao-8

Build "AnimGuild DAO" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Empower animation communities with decentralized autonomous organizations for project decisions.
Discipline: Filmmaking & Animation (community governance). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a community governance item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The community governance flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA film-animation-renderstake-9 · Base · RenderStake =====
Page: https://arcprompts.lovable.app/ideas/film-animation-renderstake-9

Build "RenderStake" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Decentralize animation rendering jobs and pay nodes through secure smart contract escrow.
Discipline: Filmmaking & Animation (distributed rendering). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a distributed rendering item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The distributed rendering flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA film-animation-animproof-timestamp-10 · Base · AnimProof Timestamp =====
Page: https://arcprompts.lovable.app/ideas/film-animation-animproof-timestamp-10

Build "AnimProof Timestamp" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Timestamp animation works to prove creation dates and prevent IP disputes with onchain records.
Discipline: Filmmaking & Animation (work timestamping). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a work timestamping item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The work timestamping flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA film-animation-voicechain-sync-11 · Base · VoiceChain Sync =====
Page: https://arcprompts.lovable.app/ideas/film-animation-voicechain-sync-11

Build "VoiceChain Sync" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Securely synchronize and timestamp voice acting tracks with animation frames on blockchain.
Discipline: Filmmaking & Animation (voice sync verification). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a voice sync verification item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The voice sync verification flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA film-animation-animtip-jar-12 · Base · AnimTip Jar =====
Page: https://arcprompts.lovable.app/ideas/film-animation-animtip-jar-12

Build "AnimTip Jar" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Let fans tip animators instantly and transparently via onchain micro-payment smart contracts.
Discipline: Filmmaking & Animation (micro-donations). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a micro-donations item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The micro-donations flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA film-animation-charanim-nft-13 · Base · CharAnim NFT =====
Page: https://arcprompts.lovable.app/ideas/film-animation-charanim-nft-13

Build "CharAnim NFT" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint trademarked animation characters as NFTs to secure and trade intellectual property rights.
Discipline: Filmmaking & Animation (character IP NFT). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a character IP NFT item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The character IP NFT flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA film-animation-animlesson-chain-14 · Base · AnimLesson Chain =====
Page: https://arcprompts.lovable.app/ideas/film-animation-animlesson-chain-14

Build "AnimLesson Chain" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Certify animation course completions and skills with blockchain-verified digital diplomas.
Discipline: Filmmaking & Animation (educational credentialing). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a educational credentialing item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The educational credentialing flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA film-animation-animcontest-dao-15 · Base · AnimContest DAO =====
Page: https://arcprompts.lovable.app/ideas/film-animation-animcontest-dao-15

Build "AnimContest DAO" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Run transparent animation contests with onchain submission tracking and automated prize distribution.
Discipline: Filmmaking & Animation (competition governance). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a competition governance item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The competition governance flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA film-animation-animscript-oracles-16 · Base · AnimScript Oracles =====
Page: https://arcprompts.lovable.app/ideas/film-animation-animscript-oracles-16

Build "AnimScript Oracles" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Use blockchain oracles to verify external animation script data integrity and authenticity onchain.
Discipline: Filmmaking & Animation (script verification). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a script verification item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The script verification flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA film-animation-animroyalties-17 · Base · AnimRoyalties =====
Page: https://arcprompts.lovable.app/ideas/film-animation-animroyalties-17

Build "AnimRoyalties" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Automate royalty payments for animation collaborators with transparent, onchain smart contracts.
Discipline: Filmmaking & Animation (royalty distribution). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a royalty distribution item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The royalty distribution flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA film-animation-scenemood-chain-18 · Base · SceneMood Chain =====
Page: https://arcprompts.lovable.app/ideas/film-animation-scenemood-chain-18

Build "SceneMood Chain" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Record color grading versions on blockchain to secure post-production creative decisions.
Discipline: Filmmaking & Animation (color grading proof). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a color grading proof item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The color grading proof flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA film-animation-animbadge-awards-19 · Base · AnimBadge Awards =====
Page: https://arcprompts.lovable.app/ideas/film-animation-animbadge-awards-19

Build "AnimBadge Awards" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Issue blockchain-verified badges and awards recognizing animator skills and achievements.
Discipline: Filmmaking & Animation (industry recognition). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a industry recognition item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The industry recognition flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA film-animation-animframe-trade-20 · Base · AnimFrame Trade =====
Page: https://arcprompts.lovable.app/ideas/film-animation-animframe-trade-20

Build "AnimFrame Trade" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
License individual animation frames securely and transparently using blockchain smart contracts.
Discipline: Filmmaking & Animation (frame licensing). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a frame licensing item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The frame licensing flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA film-animation-animpitch-fund-21 · Base · AnimPitch Fund =====
Page: https://arcprompts.lovable.app/ideas/film-animation-animpitch-fund-21

Build "AnimPitch Fund" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pitch animation projects to decentralized investors with onchain proposals and funding escrow.
Discipline: Filmmaking & Animation (project pitching). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a project pitching item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The project pitching flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA film-animation-licenchain-tracker-22 · Base · LicenChain Tracker =====
Page: https://arcprompts.lovable.app/ideas/film-animation-licenchain-tracker-22

Build "LicenChain Tracker" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Maintain an immutable audit trail of animation licenses and transfers using smart contracts.
Discipline: Filmmaking & Animation (license audit trail). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a license audit trail item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The license audit trail flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA film-animation-animmetamanager-23 · Base · AnimMetaManager =====
Page: https://arcprompts.lovable.app/ideas/film-animation-animmetamanager-23

Build "AnimMetaManager" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Securely store and update animation metadata onchain to maintain provenance and rights data.
Discipline: Filmmaking & Animation (metadata control). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a metadata control item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The metadata control flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA film-animation-animcollab-chain-24 · Base · AnimCollab Chain =====
Page: https://arcprompts.lovable.app/ideas/film-animation-animcollab-chain-24

Build "AnimCollab Chain" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Coordinate multi-artist animation projects with onchain task assignments and progress tracking.
Discipline: Filmmaking & Animation (collaborative workflows). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a collaborative workflows item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The collaborative workflows flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA film-animation-frameforge-archive-0 · Base · FrameForge Archive =====
Page: https://arcprompts.lovable.app/ideas/film-animation-frameforge-archive-0

Build "FrameForge Archive" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Securely store and share storyboards as immutable IPFS manifests to simplify team collaboration.
Discipline: Filmmaking & Animation (storyboard management). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a storyboard management sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The storyboard management flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA film-animation-texturevault-1 · Base · TextureVault =====
Page: https://arcprompts.lovable.app/ideas/film-animation-texturevault-1

Build "TextureVault" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin and catalog textures on IPFS for reuse and verified provenance in animation projects.
Discipline: Filmmaking & Animation (material asset library). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a material asset library sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The material asset library flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA film-animation-animscene-sync-2 · Base · AnimScene Sync =====
Page: https://arcprompts.lovable.app/ideas/film-animation-animscene-sync-2

Build "AnimScene Sync" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Automatically pin scene JSON manifests to IPFS to track animation iterations and changes.
Discipline: Filmmaking & Animation (scene version control). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a scene version control sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The scene version control flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA film-animation-moodboardchain-3 · Base · MoodboardChain =====
Page: https://arcprompts.lovable.app/ideas/film-animation-moodboardchain-3

Build "MoodboardChain" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Create decentralized moodboards pinned to IPFS for collaborative color grading projects.
Discipline: Filmmaking & Animation (color study curation). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a color study curation sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The color study curation flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA film-animation-rigpin-sync-4 · Base · RigPin Sync =====
Page: https://arcprompts.lovable.app/ideas/film-animation-rigpin-sync-4

Build "RigPin Sync" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Share and pin character rig files and metadata on IPFS for verified reuse across teams.
Discipline: Filmmaking & Animation (character rig sharing). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a character rig sharing sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The character rig sharing flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA film-animation-loop-provenance-5 · Base · Loop Provenance =====
Page: https://arcprompts.lovable.app/ideas/film-animation-loop-provenance-5

Build "Loop Provenance" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin looped animations on IPFS to provide artists with immutable, reusable animation cycles.
Discipline: Filmmaking & Animation (animation loop libraries). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a animation loop libraries sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The animation loop libraries flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA film-animation-scenemetastore-6 · Base · SceneMetaStore =====
Page: https://arcprompts.lovable.app/ideas/film-animation-scenemetastore-6

Build "SceneMetaStore" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Attach and pin rich JSON metadata to animation scenes, ensuring permanent scene context storage.
Discipline: Filmmaking & Animation (metadata tagging). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a metadata tagging sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The metadata tagging flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA film-animation-storyboardchain-7 · Base · StoryboardChain =====
Page: https://arcprompts.lovable.app/ideas/film-animation-storyboardchain-7

Build "StoryboardChain" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin storyboards and scripts to IPFS for tamper-proof, collaborative episodic planning.
Discipline: Filmmaking & Animation (distributed storyboarding). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a distributed storyboarding sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The distributed storyboarding flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA film-animation-animprops-ledger-8 · Base · AnimProps Ledger =====
Page: https://arcprompts.lovable.app/ideas/film-animation-animprops-ledger-8

Build "AnimProps Ledger" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Immutable pinning of prop designs on IPFS enables verified ownership and reuse across projects.
Discipline: Filmmaking & Animation (prop asset management). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a prop asset management sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The prop asset management flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA film-animation-palettechain-9 · Base · PaletteChain =====
Page: https://arcprompts.lovable.app/ideas/film-animation-palettechain-9

Build "PaletteChain" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin color palettes on IPFS for permanent, shareable references in collaborative projects.
Discipline: Filmmaking & Animation (color palette sharing). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a color palette sharing sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The color palette sharing flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA film-animation-animdata-store-10 · Base · AnimData Store =====
Page: https://arcprompts.lovable.app/ideas/film-animation-animdata-store-10

Build "AnimData Store" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin keyframe data and animation parameters to IPFS for permanent archival and collaboration.
Discipline: Filmmaking & Animation (animation data archival). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a animation data archival sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The animation data archival flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA film-animation-motionmap-vault-11 · Base · MotionMap Vault =====
Page: https://arcprompts.lovable.app/ideas/film-animation-motionmap-vault-11

Build "MotionMap Vault" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Store and pin motion capture data on IPFS ensuring permanent access and tamper-proof records.
Discipline: Filmmaking & Animation (motion capture storage). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a motion capture storage sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The motion capture storage flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA film-animation-animvoice-ledger-12 · Base · AnimVoice Ledger =====
Page: https://arcprompts.lovable.app/ideas/film-animation-animvoice-ledger-12

Build "AnimVoice Ledger" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin voiceover takes and metadata to IPFS to maintain immutable, verifiable audio assets.
Discipline: Filmmaking & Animation (voice asset management). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a voice asset management sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The voice asset management flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA film-animation-vfxchain-sync-13 · Base · VFXChain Sync =====
Page: https://arcprompts.lovable.app/ideas/film-animation-vfxchain-sync-13

Build "VFXChain Sync" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin VFX layers and settings on IPFS for permanent, sharable effects asset libraries.
Discipline: Filmmaking & Animation (effects asset curation). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a effects asset curation sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The effects asset curation flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA film-animation-animscript-pin-14 · Base · AnimScript Pin =====
Page: https://arcprompts.lovable.app/ideas/film-animation-animscript-pin-14

Build "AnimScript Pin" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin scripts and screenplays as JSON manifests on IPFS for verifiable, collaborative storytelling.
Discipline: Filmmaking & Animation (script integration). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a script integration sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The script integration flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA film-animation-animcollab-hub-15 · Base · AnimCollab Hub =====
Page: https://arcprompts.lovable.app/ideas/film-animation-animcollab-hub-15

Build "AnimCollab Hub" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Synchronize animation team files by pinning project manifests on IPFS for secure multiuser updates.
Discipline: Filmmaking & Animation (team project syncing). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a team project syncing sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The team project syncing flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA film-animation-storyboard-replay-16 · Base · Storyboard Replay =====
Page: https://arcprompts.lovable.app/ideas/film-animation-storyboard-replay-16

Build "Storyboard Replay" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin animatic sequences and frames on IPFS for permanent, shareable playback references.
Discipline: Filmmaking & Animation (animatic playback). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a animatic playback sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The animatic playback flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA film-animation-modelpin-archive-17 · Base · ModelPin Archive =====
Page: https://arcprompts.lovable.app/ideas/film-animation-modelpin-archive-17

Build "ModelPin Archive" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin 3D model metadata and previews on IPFS for permanent documentation and usage logs.
Discipline: Filmmaking & Animation (3D model documentation). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a 3D model documentation sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The 3D model documentation flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA film-animation-animfont-locker-18 · Base · AnimFont Locker =====
Page: https://arcprompts.lovable.app/ideas/film-animation-animfont-locker-18

Build "AnimFont Locker" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin custom fonts and typographic assets to IPFS for permanent reuse in animated titles.
Discipline: Filmmaking & Animation (typography asset vault). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a typography asset vault sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The typography asset vault flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA film-animation-lipsync-ledger-19 · Base · LipSync Ledger =====
Page: https://arcprompts.lovable.app/ideas/film-animation-lipsync-ledger-19

Build "LipSync Ledger" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin lipsync timing data to IPFS for permanent, sharable, and verifiable sync assets.
Discipline: Filmmaking & Animation (lipsync data storage). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a lipsync data storage sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The lipsync data storage flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA film-animation-animshot-library-20 · Base · AnimShot Library =====
Page: https://arcprompts.lovable.app/ideas/film-animation-animshot-library-20

Build "AnimShot Library" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin shot lists and planning JSON manifests on IPFS to ensure permanent, tamper-proof records.
Discipline: Filmmaking & Animation (shot list archival). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a shot list archival sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The shot list archival flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA film-animation-propchain-share-21 · Base · PropChain Share =====
Page: https://arcprompts.lovable.app/ideas/film-animation-propchain-share-21

Build "PropChain Share" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Collaboratively design and pin prop assets on IPFS with permanent version history.
Discipline: Filmmaking & Animation (prop design collaboration). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a prop design collaboration sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The prop design collaboration flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA film-animation-storyboard-captioner-22 · Base · Storyboard Captioner =====
Page: https://arcprompts.lovable.app/ideas/film-animation-storyboard-captioner-22

Build "Storyboard Captioner" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin dialogue captions linked to storyboard frames on IPFS for permanent dialogue-frame sync.
Discipline: Filmmaking & Animation (dialogue annotation). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a dialogue annotation sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The dialogue annotation flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA film-animation-animframe-swap-23 · Base · AnimFrame Swap =====
Page: https://arcprompts.lovable.app/ideas/film-animation-animframe-swap-23

Build "AnimFrame Swap" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin and trade individual animation frames on IPFS for verified ownership and provenance.
Discipline: Filmmaking & Animation (frame trading marketplace). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a frame trading marketplace sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The frame trading marketplace flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA film-animation-storyboard-sync-0 · Base · Storyboard Sync =====
Page: https://arcprompts.lovable.app/ideas/film-animation-storyboard-sync-0

Build "Storyboard Sync" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Enable real-time, gasless syncing and feedback on storyboards among filmmakers and artists.
Discipline: Filmmaking & Animation (storyboard collaboration). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a storyboard collaboration action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The storyboard collaboration flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA film-animation-animatic-drops-1 · Base · Animatic Drops =====
Page: https://arcprompts.lovable.app/ideas/film-animation-animatic-drops-1

Build "Animatic Drops" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Distribute animatics securely with embedded wallets for easy user access and sponsored preview transactions.
Discipline: Filmmaking & Animation (animatic distribution). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a animatic distribution action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The animatic distribution flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA film-animation-motion-share-2 · Base · Motion Share =====
Page: https://arcprompts.lovable.app/ideas/film-animation-motion-share-2

Build "Motion Share" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Share and collect feedback on motion graphics with instant, gasless social wallet interactions.
Discipline: Filmmaking & Animation (motion design sharing). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a motion design sharing action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The motion design sharing flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA film-animation-frame-rights-3 · Base · Frame Rights =====
Page: https://arcprompts.lovable.app/ideas/film-animation-frame-rights-3

Build "Frame Rights" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
License individual animation frames securely with embedded wallets to track ownership and transactions gas-free.
Discipline: Filmmaking & Animation (frame licensing). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a frame licensing action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The frame licensing flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA film-animation-voice-sync-4 · Base · Voice Sync =====
Page: https://arcprompts.lovable.app/ideas/film-animation-voice-sync-4

Build "Voice Sync" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Sync and verify voice-over sessions onchain with social wallets for smooth, gasless collaboration.
Discipline: Filmmaking & Animation (voice-over integration). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a voice-over integration action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The voice-over integration flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA film-animation-anim-rights-vault-5 · Base · Anim Rights Vault =====
Page: https://arcprompts.lovable.app/ideas/film-animation-anim-rights-vault-5

Build "Anim Rights Vault" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Securely store and prove animation IP ownership and usage rights with Privy-bootstrapped wallets.
Discipline: Filmmaking & Animation (animation IP protection). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a animation IP protection action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The animation IP protection flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA film-animation-render-economy-6 · Base · Render Economy =====
Page: https://arcprompts.lovable.app/ideas/film-animation-render-economy-6

Build "Render Economy" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Use gasless social wallets to coordinate and incentivize decentralized animation rendering workers.
Discipline: Filmmaking & Animation (distributed rendering). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a distributed rendering action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The distributed rendering flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA film-animation-loop-provenance-7 · Base · Loop Provenance =====
Page: https://arcprompts.lovable.app/ideas/film-animation-loop-provenance-7

Build "Loop Provenance" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Track creation history and ownership of looped animations using gasless onchain wallets.
Discipline: Filmmaking & Animation (loop animation tracking). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a loop animation tracking action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The loop animation tracking flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA film-animation-pitchchain-8 · Base · PitchChain =====
Page: https://arcprompts.lovable.app/ideas/film-animation-pitchchain-8

Build "PitchChain" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Securely record and track animation pitch submissions leveraging gasless social wallet authentication.
Discipline: Filmmaking & Animation (film pitch verification). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a film pitch verification action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The film pitch verification flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA film-animation-anim-badge-9 · Base · Anim Badge =====
Page: https://arcprompts.lovable.app/ideas/film-animation-anim-badge-9

Build "Anim Badge" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Award and verify animation skills and course completions with gasless onchain badges and wallets.
Discipline: Filmmaking & Animation (skill certification). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a skill certification action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The skill certification flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA film-animation-framechain-10 · Base · FrameChain =====
Page: https://arcprompts.lovable.app/ideas/film-animation-framechain-10

Build "FrameChain" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Record and verify each frame’s creative contribution onchain via seamless social wallet transactions.
Discipline: Filmmaking & Animation (frame-by-frame tracking). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a frame-by-frame tracking action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The frame-by-frame tracking flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA film-animation-animateswap-11 · Base · AnimateSwap =====
Page: https://arcprompts.lovable.app/ideas/film-animation-animateswap-11

Build "AnimateSwap" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Trade animation asset snippets instantly with gasless wallet transactions and social sharing built-in.
Discipline: Filmmaking & Animation (asset trading). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a asset trading action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The asset trading flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA film-animation-loopsync-12 · Base · LoopSync =====
Page: https://arcprompts.lovable.app/ideas/film-animation-loopsync-12

Build "LoopSync" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Enable collaborative editing and playback syncing of loops via gasless wallets and onchain state management.
Discipline: Filmmaking & Animation (looped animation synchronization). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a looped animation synchronization action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The looped animation synchronization flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA film-animation-designtoken-flow-13 · Base · DesignToken Flow =====
Page: https://arcprompts.lovable.app/ideas/film-animation-designtoken-flow-13

Build "DesignToken Flow" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Tokenize animation assets and track their usage flow onchain with gasless user wallet transactions.
Discipline: Filmmaking & Animation (tokenized asset flow). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a tokenized asset flow action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The tokenized asset flow flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA film-animation-animcrew-chain-14 · Base · AnimCrew Chain =====
Page: https://arcprompts.lovable.app/ideas/film-animation-animcrew-chain-14

Build "AnimCrew Chain" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Manage and reward animation production teams with gasless social wallet-based task and payout tracking.
Discipline: Filmmaking & Animation (team collaboration). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a team collaboration action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The team collaboration flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA film-animation-styleswap-15 · Base · StyleSwap =====
Page: https://arcprompts.lovable.app/ideas/film-animation-styleswap-15

Build "StyleSwap" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Exchange and remix animation styles with gasless wallet onboarding and instant transaction sponsorship.
Discipline: Filmmaking & Animation (animation style exchange). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a animation style exchange action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The animation style exchange flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA film-animation-voicechain-cast-16 · Base · VoiceChain Cast =====
Page: https://arcprompts.lovable.app/ideas/film-animation-voicechain-cast-16

Build "VoiceChain Cast" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Track voice actor rights and usage in animation projects via gasless social wallet authentication.
Discipline: Filmmaking & Animation (cast rights tracking). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a cast rights tracking action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The cast rights tracking flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA film-animation-animchain-feedback-17 · Base · AnimChain Feedback =====
Page: https://arcprompts.lovable.app/ideas/film-animation-animchain-feedback-17

Build "AnimChain Feedback" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Capture and timestamp animator feedback on projects securely and gaslessly with Privy-based wallets.
Discipline: Filmmaking & Animation (creative feedback loops). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a creative feedback loops action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The creative feedback loops flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA film-animation-metascene-ledger-18 · Base · MetaScene Ledger =====
Page: https://arcprompts.lovable.app/ideas/film-animation-metascene-ledger-18

Build "MetaScene Ledger" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Track all metadata changes in animation scenes onchain with gasless wallet updates for full provenance.
Discipline: Filmmaking & Animation (scene metadata tracking). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a scene metadata tracking action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The scene metadata tracking flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA film-animation-clipchain-share-19 · Base · ClipChain Share =====
Page: https://arcprompts.lovable.app/ideas/film-animation-clipchain-share-19

Build "ClipChain Share" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Share animation clips instantly with embedded wallets enabling gasless transfers and social proof.
Discipline: Filmmaking & Animation (clip sharing). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a clip sharing action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The clip sharing flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA film-animation-animfeedback-nft-20 · Base · AnimFeedback NFT =====
Page: https://arcprompts.lovable.app/ideas/film-animation-animfeedback-nft-20

Build "AnimFeedback NFT" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Monetize animation feedback as NFTs with Privy wallets enabling gas-free minting and transactions.
Discipline: Filmmaking & Animation (feedback monetization). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a feedback monetization action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The feedback monetization flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA film-animation-storyboard-mint-21 · Base · Storyboard Mint =====
Page: https://arcprompts.lovable.app/ideas/film-animation-storyboard-mint-21

Build "Storyboard Mint" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint storyboards as gasless NFTs via embedded social wallets for easy ownership and transfer.
Discipline: Filmmaking & Animation (storyboard NFT minting). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a storyboard NFT minting action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The storyboard NFT minting flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA film-animation-anim-guild-22 · Base · Anim Guild =====
Page: https://arcprompts.lovable.app/ideas/film-animation-anim-guild-22

Build "Anim Guild" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Create animator guilds with onchain membership and governance via gasless Privy wallet interactions.
Discipline: Filmmaking & Animation (community governance). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a community governance action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The community governance flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA film-animation-motiontrack-rewards-23 · Base · MotionTrack Rewards =====
Page: https://arcprompts.lovable.app/ideas/film-animation-motiontrack-rewards-23

Build "MotionTrack Rewards" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Reward motion designers instantly with sponsored gasless wallet transactions tied to creative milestones.
Discipline: Filmmaking & Animation (performance incentives). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a performance incentives action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The performance incentives flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA film-animation-clipchain-rights-24 · Base · ClipChain Rights =====
Page: https://arcprompts.lovable.app/ideas/film-animation-clipchain-rights-24

Build "ClipChain Rights" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Manage animation clip rights transparently with onchain wallet transactions and gasless sponsored operations.
Discipline: Filmmaking & Animation (clip rights management). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a clip rights management action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The clip rights management flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA film-animation-framechain-legacy-0 · Base · FrameChain Legacy =====
Page: https://arcprompts.lovable.app/ideas/film-animation-framechain-legacy-0

Build "FrameChain Legacy" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Securely mint unique storyboard sequences proving original authorship and evolution.
Discipline: Filmmaking & Animation (storyboard provenance). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a storyboard provenance work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The storyboard provenance flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA film-animation-animmint-vault-1 · Base · AnimMint Vault =====
Page: https://arcprompts.lovable.app/ideas/film-animation-animmint-vault-1

Build "AnimMint Vault" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Create NFT-verified character animations to authenticate originality and usage rights.
Discipline: Filmmaking & Animation (character animation). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a character animation work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The character animation flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA film-animation-scenestamp-auth-2 · Base · SceneStamp Auth =====
Page: https://arcprompts.lovable.app/ideas/film-animation-scenestamp-auth-2

Build "SceneStamp Auth" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint entire scene compositions as NFTs to protect creative framing and direction.
Discipline: Filmmaking & Animation (scene composition). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a scene composition work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The scene composition flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA film-animation-motionmark-ledger-3 · Base · MotionMark Ledger =====
Page: https://arcprompts.lovable.app/ideas/film-animation-motionmark-ledger-3

Build "MotionMark Ledger" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Authenticate motion design clips with NFT provenance for fair distribution and recognition.
Discipline: Filmmaking & Animation (motion design). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a motion design work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The motion design flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA film-animation-colorproof-chain-4 · Base · ColorProof Chain =====
Page: https://arcprompts.lovable.app/ideas/film-animation-colorproof-chain-4

Build "ColorProof Chain" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint color grading profiles as NFTs to guarantee creative credits and prevent misuse.
Discipline: Filmmaking & Animation (color grading). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a color grading work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The color grading flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA film-animation-vfx-provenance-5 · Base · VFX Provenance =====
Page: https://arcprompts.lovable.app/ideas/film-animation-vfx-provenance-5

Build "VFX Provenance" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Secure VFX shots as NFTs ensuring rightful ownership and usage tracking across productions.
Discipline: Filmmaking & Animation (visual effects). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a visual effects work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The visual effects flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA film-animation-propmint-archive-6 · Base · PropMint Archive =====
Page: https://arcprompts.lovable.app/ideas/film-animation-propmint-archive-6

Build "PropMint Archive" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint 3D prop assets as NFTs to certify originality and control licensing.
Discipline: Filmmaking & Animation (3D prop modeling). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a 3D prop modeling work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The 3D prop modeling flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA film-animation-voicetrack-token-7 · Base · VoiceTrack Token =====
Page: https://arcprompts.lovable.app/ideas/film-animation-voicetrack-token-7

Build "VoiceTrack Token" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Authenticate voiceover clips with provenance NFTs ensuring creator recognition and rights.
Discipline: Filmmaking & Animation (voiceover recording). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a voiceover recording work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The voiceover recording flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA film-animation-animsound-ledger-8 · Base · AnimSound Ledger =====
Page: https://arcprompts.lovable.app/ideas/film-animation-animsound-ledger-8

Build "AnimSound Ledger" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint sound design elements as NFTs verifying originality and usage permissions.
Discipline: Filmmaking & Animation (sound design). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a sound design work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The sound design flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA film-animation-storyboard-chain-9 · Base · Storyboard Chain =====
Page: https://arcprompts.lovable.app/ideas/film-animation-storyboard-chain-9

Build "Storyboard Chain" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Secure visual storyboards on-chain to track creator rights and version history.
Discipline: Filmmaking & Animation (visual storytelling). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a visual storytelling work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The visual storytelling flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA film-animation-animloop-provenance-10 · Base · AnimLoop Provenance =====
Page: https://arcprompts.lovable.app/ideas/film-animation-animloop-provenance-10

Build "AnimLoop Provenance" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Create provenance-backed NFT loops ensuring traceable animation reuse and credit.
Discipline: Filmmaking & Animation (animation loops). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a animation loops work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The animation loops flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA film-animation-cuttoken-verify-11 · Base · CutToken Verify =====
Page: https://arcprompts.lovable.app/ideas/film-animation-cuttoken-verify-11

Build "CutToken Verify" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint finalized film cuts as NFTs to guarantee ownership and distribution rights.
Discipline: Filmmaking & Animation (film editing). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a film editing work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The film editing flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA film-animation-storyboardchain-script-12 · Base · StoryboardChain Script =====
Page: https://arcprompts.lovable.app/ideas/film-animation-storyboardchain-script-12

Build "StoryboardChain Script" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint script drafts as NFTs to secure writing credits and version control.
Discipline: Filmmaking & Animation (script development). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a script development work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The script development flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA film-animation-moodboard-token-13 · Base · MoodBoard Token =====
Page: https://arcprompts.lovable.app/ideas/film-animation-moodboard-token-13

Build "MoodBoard Token" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Authenticate concept moodboards as NFTs protecting early creative vision rights.
Discipline: Filmmaking & Animation (concept art). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a concept art work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The concept art flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA film-animation-animframe-tag-14 · Base · AnimFrame Tag =====
Page: https://arcprompts.lovable.app/ideas/film-animation-animframe-tag-14

Build "AnimFrame Tag" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint keyframes as NFTs to prove original frame animation ownership and usage.
Discipline: Filmmaking & Animation (frame-by-frame animation). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a frame-by-frame animation work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The frame-by-frame animation flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA film-animation-storyboardclip-token-15 · Base · StoryboardClip Token =====
Page: https://arcprompts.lovable.app/ideas/film-animation-storyboardclip-token-15

Build "StoryboardClip Token" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint animatic clips as NFTs to secure early-stage animated story ownership.
Discipline: Filmmaking & Animation (animatic creation). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a animatic creation work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The animatic creation flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA film-animation-charactermint-badge-16 · Base · CharacterMint Badge =====
Page: https://arcprompts.lovable.app/ideas/film-animation-charactermint-badge-16

Build "CharacterMint Badge" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Authenticate character design sheets as NFTs to establish creator credit and licensing.
Discipline: Filmmaking & Animation (character design). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a character design work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The character design flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA film-animation-animvoice-ledger-17 · Base · AnimVoice Ledger =====
Page: https://arcprompts.lovable.app/ideas/film-animation-animvoice-ledger-17

Build "AnimVoice Ledger" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint voice acting performances as NFTs proving rights and enabling royalty tracking.
Discipline: Filmmaking & Animation (voice acting). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a voice acting work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The voice acting flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA film-animation-propchain-license-18 · Base · PropChain License =====
Page: https://arcprompts.lovable.app/ideas/film-animation-propchain-license-18

Build "PropChain License" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint rental licenses as NFTs for 3D props enabling secure temporary usage.
Discipline: Filmmaking & Animation (virtual prop rental). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a virtual prop rental work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The virtual prop rental flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA film-animation-animtext-token-19 · Base · AnimText Token =====
Page: https://arcprompts.lovable.app/ideas/film-animation-animtext-token-19

Build "AnimText Token" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint animated typography clips as NFTs to secure originality and distribution rights.
Discipline: Filmmaking & Animation (animated typography). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a animated typography work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The animated typography flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA film-animation-sceneaccess-pass-20 · Base · SceneAccess Pass =====
Page: https://arcprompts.lovable.app/ideas/film-animation-sceneaccess-pass-20

Build "SceneAccess Pass" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint NFT passes granting creator access to virtual production scene data and assets.
Discipline: Filmmaking & Animation (virtual production). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a virtual production work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The virtual production flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA film-animation-animsketch-token-21 · Base · AnimSketch Token =====
Page: https://arcprompts.lovable.app/ideas/film-animation-animsketch-token-21

Build "AnimSketch Token" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint animator sketchbooks as NFTs to prove original creative process ownership.
Discipline: Filmmaking & Animation (animator sketchbooks). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a animator sketchbooks work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The animator sketchbooks flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA film-animation-storyboardsync-ledger-22 · Base · StoryboardSync Ledger =====
Page: https://arcprompts.lovable.app/ideas/film-animation-storyboardsync-ledger-22

Build "StoryboardSync Ledger" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint NFT storyboards to track collaborative edits and contributions transparently.
Discipline: Filmmaking & Animation (collaborative storyboarding). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a collaborative storyboarding work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The collaborative storyboarding flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA film-animation-animpitch-token-23 · Base · AnimPitch Token =====
Page: https://arcprompts.lovable.app/ideas/film-animation-animpitch-token-23

Build "AnimPitch Token" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint NFT pitch decks for animation projects guaranteeing originality and creator rights.
Discipline: Filmmaking & Animation (project pitching). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a project pitching work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The project pitching flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA film-animation-animcycle-provenance-24 · Base · AnimCycle Provenance =====
Page: https://arcprompts.lovable.app/ideas/film-animation-animcycle-provenance-24

Build "AnimCycle Provenance" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint NFT walk and run cycles to protect proprietary animation loops and licensing.
Discipline: Filmmaking & Animation (loop cycles). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a loop cycles work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The loop cycles flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA games-onchain-quest-ledger-0 · Base · Onchain Quest Ledger =====
Page: https://arcprompts.lovable.app/ideas/games-onchain-quest-ledger-0

Build "Onchain Quest Ledger" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Securely log player quest progress and achievements on Ethereum Sepolia to prove in-game milestones.
Discipline: Game Design & Interactive Media (quest tracking). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a quest tracking item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The quest tracking flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA games-tokenized-loot-drops-1 · Base · Tokenized Loot Drops =====
Page: https://arcprompts.lovable.app/ideas/games-tokenized-loot-drops-1

Build "Tokenized Loot Drops" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Distribute rare, verifiable loot as tokens directly through Sepolia smart contracts to guarantee authenticity.
Discipline: Game Design & Interactive Media (item distribution). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a item distribution item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The item distribution flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA games-player-reputation-ledger-2 · Base · Player Reputation Ledger =====
Page: https://arcprompts.lovable.app/ideas/games-player-reputation-ledger-2

Build "Player Reputation Ledger" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Create immutable player reputation scores recorded on Sepolia to foster fair matchmaking and collaboration.
Discipline: Game Design & Interactive Media (community trust). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a community trust item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The community trust flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA games-onchain-puzzle-locks-3 · Base · Onchain Puzzle Locks =====
Page: https://arcprompts.lovable.app/ideas/games-onchain-puzzle-locks-3

Build "Onchain Puzzle Locks" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Design puzzles whose solutions must be proven onchain via Sepolia smart contracts to unlock game content.
Discipline: Game Design & Interactive Media (interactive puzzles). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a interactive puzzles item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The interactive puzzles flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA games-immutable-scoreboards-4 · Base · Immutable Scoreboards =====
Page: https://arcprompts.lovable.app/ideas/games-immutable-scoreboards-4

Build "Immutable Scoreboards" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Store game scores on Sepolia to prevent cheating and create permanent leaderboards.
Discipline: Game Design & Interactive Media (competitive scoring). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a competitive scoring item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The competitive scoring flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA games-collectible-avatars-5 · Base · Collectible Avatars =====
Page: https://arcprompts.lovable.app/ideas/games-collectible-avatars-5

Build "Collectible Avatars" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint avatar parts as unique tokens on Sepolia, enabling player-owned, tradable character features.
Discipline: Game Design & Interactive Media (character customization). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a character customization item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The character customization flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA games-onchain-narrative-branches-6 · Base · Onchain Narrative Branches =====
Page: https://arcprompts.lovable.app/ideas/games-onchain-narrative-branches-6

Build "Onchain Narrative Branches" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Record player story choices on Sepolia to create transparent, shared branching narratives.
Discipline: Game Design & Interactive Media (storytelling). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a storytelling item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The storytelling flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA games-decentralized-game-voting-7 · Base · Decentralized Game Voting =====
Page: https://arcprompts.lovable.app/ideas/games-decentralized-game-voting-7

Build "Decentralized Game Voting" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Empower players to vote on game decisions using Sepolia smart contracts for transparent results.
Discipline: Game Design & Interactive Media (community governance). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a community governance item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The community governance flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA games-proof-of-play-events-8 · Base · Proof-of-Play Events =====
Page: https://arcprompts.lovable.app/ideas/games-proof-of-play-events-8

Build "Proof-of-Play Events" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Authenticate player participation in timed events on Sepolia for exclusive rewards and recognition.
Discipline: Game Design & Interactive Media (event verification). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a event verification item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The event verification flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA games-onchain-multiplayer-matchmaking-9 · Base · Onchain Multiplayer Matchmaking =====
Page: https://arcprompts.lovable.app/ideas/games-onchain-multiplayer-matchmaking-9

Build "Onchain Multiplayer Matchmaking" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Use Sepolia to transparently pair players based on verified criteria ensuring fairness.
Discipline: Game Design & Interactive Media (match coordination). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a match coordination item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The match coordination flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA games-rare-achievement-tokens-10 · Base · Rare Achievement Tokens =====
Page: https://arcprompts.lovable.app/ideas/games-rare-achievement-tokens-10

Build "Rare Achievement Tokens" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint unique achievement tokens on Sepolia when players hit milestones to prove in-game skills.
Discipline: Game Design & Interactive Media (achievement systems). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a achievement systems item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The achievement systems flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA games-onchain-virtual-economies-11 · Base · Onchain Virtual Economies =====
Page: https://arcprompts.lovable.app/ideas/games-onchain-virtual-economies-11

Build "Onchain Virtual Economies" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Manage in-game currency and item economies via Sepolia smart contracts for secure, transparent transactions.
Discipline: Game Design & Interactive Media (economy management). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a economy management item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The economy management flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA games-dynamic-nft-game-assets-12 · Base · Dynamic NFT Game Assets =====
Page: https://arcprompts.lovable.app/ideas/games-dynamic-nft-game-assets-12

Build "Dynamic NFT Game Assets" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Allow game assets to evolve on Sepolia based on gameplay, creating unique player-owned NFTs.
Discipline: Game Design & Interactive Media (asset evolution). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a asset evolution item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The asset evolution flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA games-onchain-scavenger-hunts-13 · Base · Onchain Scavenger Hunts =====
Page: https://arcprompts.lovable.app/ideas/games-onchain-scavenger-hunts-13

Build "Onchain Scavenger Hunts" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Create geolocated scavenger hunts tracked and verified on Sepolia to reward player discoveries.
Discipline: Game Design & Interactive Media (interactive exploration). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a interactive exploration item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The interactive exploration flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA games-transparent-rng-mechanics-14 · Base · Transparent RNG Mechanics =====
Page: https://arcprompts.lovable.app/ideas/games-transparent-rng-mechanics-14

Build "Transparent RNG Mechanics" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Implement verifiable random number generation on Sepolia to ensure fair game outcomes.
Discipline: Game Design & Interactive Media (game fairness). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a game fairness item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The game fairness flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA games-onchain-skill-trees-15 · Base · Onchain Skill Trees =====
Page: https://arcprompts.lovable.app/ideas/games-onchain-skill-trees-15

Build "Onchain Skill Trees" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Record and validate player skill tree choices on Sepolia ensuring unique character builds are guaranteed.
Discipline: Game Design & Interactive Media (character progression). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a character progression item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The character progression flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA games-decentralized-story-co-creation-16 · Base · Decentralized Story Co-Creation =====
Page: https://arcprompts.lovable.app/ideas/games-decentralized-story-co-creation-16

Build "Decentralized Story Co-Creation" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Facilitate community-driven story creation by recording contributions on Sepolia for transparent authorship.
Discipline: Game Design & Interactive Media (collaborative narrative). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a collaborative narrative item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The collaborative narrative flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA games-onchain-game-jam-scores-17 · Base · Onchain Game Jam Scores =====
Page: https://arcprompts.lovable.app/ideas/games-onchain-game-jam-scores-17

Build "Onchain Game Jam Scores" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Publish and verify game jam scores on Sepolia to ensure fairness and public recognition.
Discipline: Game Design & Interactive Media (competition scoring). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a competition scoring item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The competition scoring flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA games-player-created-onchain-items-18 · Base · Player-Created Onchain Items =====
Page: https://arcprompts.lovable.app/ideas/games-player-created-onchain-items-18

Build "Player-Created Onchain Items" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Allow players to mint and trade custom items on Sepolia smart contracts within games.
Discipline: Game Design & Interactive Media (user-generated content). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a user-generated content item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The user-generated content flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA games-onchain-vr-experience-logs-19 · Base · Onchain VR Experience Logs =====
Page: https://arcprompts.lovable.app/ideas/games-onchain-vr-experience-logs-19

Build "Onchain VR Experience Logs" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Record user interactions in VR on Sepolia for secure session histories and experience sharing.
Discipline: Game Design & Interactive Media (immersive interaction). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a immersive interaction item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The immersive interaction flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA games-blockchain-dialogue-trees-20 · Base · Blockchain Dialogue Trees =====
Page: https://arcprompts.lovable.app/ideas/games-blockchain-dialogue-trees-20

Build "Blockchain Dialogue Trees" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Store branching dialogue choices on Sepolia to enable transparent player-driven storytelling.
Discipline: Game Design & Interactive Media (interactive dialogue). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a interactive dialogue item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The interactive dialogue flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA games-onchain-speedrun-verification-21 · Base · Onchain Speedrun Verification =====
Page: https://arcprompts.lovable.app/ideas/games-onchain-speedrun-verification-21

Build "Onchain Speedrun Verification" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Verify and timestamp speedrun attempts on Sepolia smart contracts to prevent cheating.
Discipline: Game Design & Interactive Media (challenge validation). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a challenge validation item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The challenge validation flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA games-decentralized-game-mods-22 · Base · Decentralized Game Mods =====
Page: https://arcprompts.lovable.app/ideas/games-decentralized-game-mods-22

Build "Decentralized Game Mods" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Distribute and verify mods using Sepolia smart contracts for secure, community-driven content sharing.
Discipline: Game Design & Interactive Media (mod distribution). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a mod distribution item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The mod distribution flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA games-token-gated-game-access-23 · Base · Token-Gated Game Access =====
Page: https://arcprompts.lovable.app/ideas/games-token-gated-game-access-23

Build "Token-Gated Game Access" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Use Sepolia smart contracts to restrict game content access via ownership of specific tokens.
Discipline: Game Design & Interactive Media (access control). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a access control item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The access control flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA games-onchain-interactive-artpieces-24 · Base · Onchain Interactive Artpieces =====
Page: https://arcprompts.lovable.app/ideas/games-onchain-interactive-artpieces-24

Build "Onchain Interactive Artpieces" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Create interactive artworks whose states and ownership are controlled via Sepolia smart contracts.
Discipline: Game Design & Interactive Media (generative art). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a generative art item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The generative art flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA games-pixel-lore-vault-0 · Base · Pixel Lore Vault =====
Page: https://arcprompts.lovable.app/ideas/games-pixel-lore-vault-0

Build "Pixel Lore Vault" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Permanently store and share evolving game storylines and lore across player communities.
Discipline: Game Design & Interactive Media (game narrative archiving). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a game narrative archiving sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The game narrative archiving flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA games-avatar-trait-forge-1 · Base · Avatar Trait Forge =====
Page: https://arcprompts.lovable.app/ideas/games-avatar-trait-forge-1

Build "Avatar Trait Forge" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Save and share unique character traits and skins securely and permanently on IPFS.
Discipline: Game Design & Interactive Media (character customization data). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a character customization data sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The character customization data flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA games-quest-chain-archive-2 · Base · Quest Chain Archive =====
Page: https://arcprompts.lovable.app/ideas/games-quest-chain-archive-2

Build "Quest Chain Archive" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Distribute permanent quest data and decision trees for replayable and modifiable game adventures.
Discipline: Game Design & Interactive Media (interactive quest design). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a interactive quest design sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The interactive quest design flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA games-xr-scene-snapshot-3 · Base · XR Scene Snapshot =====
Page: https://arcprompts.lovable.app/ideas/games-xr-scene-snapshot-3

Build "XR Scene Snapshot" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin immersive XR scenes and metadata permanently for cross-platform sharing and reuse.
Discipline: Game Design & Interactive Media (extended reality content storage). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a extended reality content storage sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The extended reality content storage flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA games-procedural-map-depository-4 · Base · Procedural Map Depository =====
Page: https://arcprompts.lovable.app/ideas/games-procedural-map-depository-4

Build "Procedural Map Depository" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Securely archive and share procedurally generated game maps for community use and collaboration.
Discipline: Game Design & Interactive Media (map generation and sharing). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a map generation and sharing sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The map generation and sharing flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA games-artifact-provenance-ledger-5 · Base · Artifact Provenance Ledger =====
Page: https://arcprompts.lovable.app/ideas/games-artifact-provenance-ledger-5

Build "Artifact Provenance Ledger" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Track and preserve full history of rare game artifacts immutably for authentic ownership proof.
Discipline: Game Design & Interactive Media (in-game item history tracking). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a in-game item history tracking sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The in-game item history tracking flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA games-audio-loop-library-6 · Base · Audio Loop Library =====
Page: https://arcprompts.lovable.app/ideas/games-audio-loop-library-6

Build "Audio Loop Library" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Curate and permanently store unique game audio loops for easy reuse and remixing.
Discipline: Game Design & Interactive Media (sound asset curation). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a sound asset curation sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The sound asset curation flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA games-interactive-comic-archive-7 · Base · Interactive Comic Archive =====
Page: https://arcprompts.lovable.app/ideas/games-interactive-comic-archive-7

Build "Interactive Comic Archive" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin interactive comic panels and scripts securely to enable decentralized reader-driven narratives.
Discipline: Game Design & Interactive Media (visual storytelling). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a visual storytelling sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The visual storytelling flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA games-ai-npc-memory-hub-8 · Base · AI NPC Memory Hub =====
Page: https://arcprompts.lovable.app/ideas/games-ai-npc-memory-hub-8

Build "AI NPC Memory Hub" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Store AI NPC dialogue and memory states permanently for persistent, evolving game worlds.
Discipline: Game Design & Interactive Media (non-player character data). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a non-player character data sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The non-player character data flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA games-glyph-pattern-codex-9 · Base · Glyph Pattern Codex =====
Page: https://arcprompts.lovable.app/ideas/games-glyph-pattern-codex-9

Build "Glyph Pattern Codex" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Archive unique glyphs and icon sets on IPFS for universal use in games and media.
Discipline: Game Design & Interactive Media (symbol and icon design). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a symbol and icon design sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The symbol and icon design flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA games-mod-manifest-vault-10 · Base · Mod Manifest Vault =====
Page: https://arcprompts.lovable.app/ideas/games-mod-manifest-vault-10

Build "Mod Manifest Vault" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin and share mod manifests permanently to enable decentralized mod discovery and trust.
Discipline: Game Design & Interactive Media (game modification metadata). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a game modification metadata sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The game modification metadata flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA games-dynamic-ui-blueprint-11 · Base · Dynamic UI Blueprint =====
Page: https://arcprompts.lovable.app/ideas/games-dynamic-ui-blueprint-11

Build "Dynamic UI Blueprint" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Save and distribute dynamic game UI states and settings with permanent accessibility.
Discipline: Game Design & Interactive Media (interface state storage). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a interface state storage sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The interface state storage flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA games-lore-collaboration-board-12 · Base · Lore Collaboration Board =====
Page: https://arcprompts.lovable.app/ideas/games-lore-collaboration-board-12

Build "Lore Collaboration Board" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Enable community-driven lore contributions to be pinned permanently, ensuring collective narrative ownership.
Discipline: Game Design & Interactive Media (community storytelling). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a community storytelling sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The community storytelling flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA games-playable-prop-archive-13 · Base · Playable Prop Archive =====
Page: https://arcprompts.lovable.app/ideas/games-playable-prop-archive-13

Build "Playable Prop Archive" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Permanently store props and interactive assets for reusable, verifiable game object libraries.
Discipline: Game Design & Interactive Media (asset permanence). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a asset permanence sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The asset permanence flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA games-speedrun-data-ledger-14 · Base · Speedrun Data Ledger =====
Page: https://arcprompts.lovable.app/ideas/games-speedrun-data-ledger-14

Build "Speedrun Data Ledger" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin detailed speedrun metadata and replay JSONs permanently for competitive integrity and sharing.
Discipline: Game Design & Interactive Media (game performance recording). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a game performance recording sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The game performance recording flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA games-virtual-stage-archives-15 · Base · Virtual Stage Archives =====
Page: https://arcprompts.lovable.app/ideas/games-virtual-stage-archives-15

Build "Virtual Stage Archives" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Store and preserve virtual stage designs and performance manifests for XR and live events.
Discipline: Game Design & Interactive Media (interactive performance spaces). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a interactive performance spaces sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The interactive performance spaces flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA games-emotion-filter-pack-16 · Base · Emotion Filter Pack =====
Page: https://arcprompts.lovable.app/ideas/games-emotion-filter-pack-16

Build "Emotion Filter Pack" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin and share unique emotion-driven visual filters permanently for character and scene enhancement.
Discipline: Game Design & Interactive Media (visual effect assets). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a visual effect assets sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The visual effect assets flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA games-puzzle-logic-cache-17 · Base · Puzzle Logic Cache =====
Page: https://arcprompts.lovable.app/ideas/games-puzzle-logic-cache-17

Build "Puzzle Logic Cache" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Store complex puzzle logic and solution paths immutably for community puzzle sharing and remixing.
Discipline: Game Design & Interactive Media (game mechanic storage). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a game mechanic storage sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The game mechanic storage flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA games-lore-token-index-18 · Base · Lore Token Index =====
Page: https://arcprompts.lovable.app/ideas/games-lore-token-index-18

Build "Lore Token Index" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Create permanent indexes linking lore tokens to their corresponding IPFS-hosted metadata manifests.
Discipline: Game Design & Interactive Media (metadata indexing). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a metadata indexing sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The metadata indexing flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA games-multiplayer-mod-sync-19 · Base · Multiplayer Mod Sync =====
Page: https://arcprompts.lovable.app/ideas/games-multiplayer-mod-sync-19

Build "Multiplayer Mod Sync" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin mods and game asset manifests to IPFS for real-time multiplayer mod synchronization.
Discipline: Game Design & Interactive Media (cross-user asset distribution). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a cross-user asset distribution sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The cross-user asset distribution flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA games-interactive-soundscapes-20 · Base · Interactive Soundscapes =====
Page: https://arcprompts.lovable.app/ideas/games-interactive-soundscapes-20

Build "Interactive Soundscapes" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin rich, layered ambient soundscapes permanently for immersive and customizable game atmospheres.
Discipline: Game Design & Interactive Media (ambient audio curation). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a ambient audio curation sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The ambient audio curation flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA games-immersive-narrative-nodes-21 · Base · Immersive Narrative Nodes =====
Page: https://arcprompts.lovable.app/ideas/games-immersive-narrative-nodes-21

Build "Immersive Narrative Nodes" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Store branching narrative nodes permanently to enable expansive, decentralized interactive storytelling.
Discipline: Game Design & Interactive Media (branching story data). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a branching story data sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The branching story data flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA games-xr-artifact-library-22 · Base · XR Artifact Library =====
Page: https://arcprompts.lovable.app/ideas/games-xr-artifact-library-22

Build "XR Artifact Library" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Archive and share 3D XR artifacts via IPFS, ensuring permanent access to virtual museum pieces.
Discipline: Game Design & Interactive Media (3D object preservation). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a 3D object preservation sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The 3D object preservation flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA games-game-jam-showcase-23 · Base · Game Jam Showcase =====
Page: https://arcprompts.lovable.app/ideas/games-game-jam-showcase-23

Build "Game Jam Showcase" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Permanently pin game jam project assets and manifests to showcase creative works indefinitely.
Discipline: Game Design & Interactive Media (project preservation). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a project preservation sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The project preservation flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA games-tokenized-lore-boards-24 · Base · Tokenized Lore Boards =====
Page: https://arcprompts.lovable.app/ideas/games-tokenized-lore-boards-24

Build "Tokenized Lore Boards" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Create permanent, token-linked lore boards for collaborative and credentialed story creation.
Discipline: Game Design & Interactive Media (community content curation). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a community content curation sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The community content curation flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA games-gasless-guilds-0 · Base · Gasless Guilds =====
Page: https://arcprompts.lovable.app/ideas/games-gasless-guilds-0

Build "Gasless Guilds" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Seamlessly create and join guilds with gas-free onboarding and instant member transactions.
Discipline: Game Design & Interactive Media (multiplayer coordination). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a multiplayer coordination action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The multiplayer coordination flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA games-sponsored-loot-drops-1 · Base · Sponsored Loot Drops =====
Page: https://arcprompts.lovable.app/ideas/games-sponsored-loot-drops-1

Build "Sponsored Loot Drops" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Distribute in-game rewards directly to players' wallets without any gas fees.
Discipline: Game Design & Interactive Media (reward distribution). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a reward distribution action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The reward distribution flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA games-privy-vr-lobby-2 · Base · Privy VR Lobby =====
Page: https://arcprompts.lovable.app/ideas/games-privy-vr-lobby-2

Build "Privy VR Lobby" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Enter virtual lobbies with gas-free wallet login and seamless social interactions.
Discipline: Game Design & Interactive Media (XR social spaces). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a XR social spaces action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The XR social spaces flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA games-onchain-avatar-store-3 · Base · Onchain Avatar Store =====
Page: https://arcprompts.lovable.app/ideas/games-onchain-avatar-store-3

Build "Onchain Avatar Store" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Buy and customize avatars with zero gas fees using embedded wallets and sponsored transactions.
Discipline: Game Design & Interactive Media (digital fashion). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a digital fashion action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The digital fashion flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA games-social-quest-chains-4 · Base · Social Quest Chains =====
Page: https://arcprompts.lovable.app/ideas/games-social-quest-chains-4

Build "Social Quest Chains" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Collaborate on story-driven quests with gasless wallet sign-in and transaction sponsorship.
Discipline: Game Design & Interactive Media (interactive storytelling). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a interactive storytelling action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The interactive storytelling flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA games-gasless-xr-art-swap-5 · Base · Gasless XR Art Swap =====
Page: https://arcprompts.lovable.app/ideas/games-gasless-xr-art-swap-5

Build "Gasless XR Art Swap" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Trade XR art pieces effortlessly with embedded wallets and sponsored transactions.
Discipline: Game Design & Interactive Media (interactive art exchange). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a interactive art exchange action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The interactive art exchange flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA games-privy-game-jam-6 · Base · Privy Game Jam =====
Page: https://arcprompts.lovable.app/ideas/games-privy-game-jam-6

Build "Privy Game Jam" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Host game jams with onchain identity and gas-free participation transactions.
Discipline: Game Design & Interactive Media (developer community). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a developer community action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The developer community flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA games-sponsored-beta-access-7 · Base · Sponsored Beta Access =====
Page: https://arcprompts.lovable.app/ideas/games-sponsored-beta-access-7

Build "Sponsored Beta Access" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Grant beta testing access through gasless wallet authentication and sponsored invites.
Discipline: Game Design & Interactive Media (user testing). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a user testing action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The user testing flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA games-privy-scoreboard-8 · Base · Privy Scoreboard =====
Page: https://arcprompts.lovable.app/ideas/games-privy-scoreboard-8

Build "Privy Scoreboard" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Display and update player rankings with gas-free wallet sign-in and transaction updates.
Discipline: Game Design & Interactive Media (competitive ranking). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a competitive ranking action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The competitive ranking flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA games-instant-nft-trades-9 · Base · Instant NFT Trades =====
Page: https://arcprompts.lovable.app/ideas/games-instant-nft-trades-9

Build "Instant NFT Trades" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Buy and sell game NFTs instantly with embedded wallets and zero gas fees.
Discipline: Game Design & Interactive Media (marketplace integration). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a marketplace integration action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The marketplace integration flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA games-gasless-avatar-gifting-10 · Base · Gasless Avatar Gifting =====
Page: https://arcprompts.lovable.app/ideas/games-gasless-avatar-gifting-10

Build "Gasless Avatar Gifting" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Send avatar skins and items as gifts without any gas fees.
Discipline: Game Design & Interactive Media (social gifting). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a social gifting action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The social gifting flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA games-sponsored-skill-boosts-11 · Base · Sponsored Skill Boosts =====
Page: https://arcprompts.lovable.app/ideas/games-sponsored-skill-boosts-11

Build "Sponsored Skill Boosts" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Grant skill boosts and power-ups via gasless wallet transactions.
Discipline: Game Design & Interactive Media (in-game perks). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a in-game perks action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The in-game perks flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA games-privy-story-worlds-12 · Base · Privy Story Worlds =====
Page: https://arcprompts.lovable.app/ideas/games-privy-story-worlds-12

Build "Privy Story Worlds" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Create and share story-driven worlds with gasless wallet logins and sponsored content publishing.
Discipline: Game Design & Interactive Media (user-generated content). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a user-generated content action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The user-generated content flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA games-gas-free-co-op-play-13 · Base · Gas-Free Co-op Play =====
Page: https://arcprompts.lovable.app/ideas/games-gas-free-co-op-play-13

Build "Gas-Free Co-op Play" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Join cooperative matches instantly with gasless wallet onboarding and sponsored sync transactions.
Discipline: Game Design & Interactive Media (multiplayer mechanics). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a multiplayer mechanics action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The multiplayer mechanics flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA games-sponsored-xr-avatars-14 · Base · Sponsored XR Avatars =====
Page: https://arcprompts.lovable.app/ideas/games-sponsored-xr-avatars-14

Build "Sponsored XR Avatars" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Equip XR avatars with sponsored token transactions and easy wallet sign-in.
Discipline: Game Design & Interactive Media (virtual identity). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a virtual identity action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The virtual identity flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA games-privy-puzzle-rewards-15 · Base · Privy Puzzle Rewards =====
Page: https://arcprompts.lovable.app/ideas/games-privy-puzzle-rewards-15

Build "Privy Puzzle Rewards" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Earn puzzle completion rewards with gas-free wallet sign-in and transaction sponsorship.
Discipline: Game Design & Interactive Media (casual game incentives). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a casual game incentives action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The casual game incentives flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA games-gasless-avatar-battles-16 · Base · Gasless Avatar Battles =====
Page: https://arcprompts.lovable.app/ideas/games-gasless-avatar-battles-16

Build "Gasless Avatar Battles" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Compete in avatar battles with gas-free wallet authentication and sponsored match transactions.
Discipline: Game Design & Interactive Media (competitive avatars). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a competitive avatars action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The competitive avatars flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA games-sponsored-xr-exhibits-17 · Base · Sponsored XR Exhibits =====
Page: https://arcprompts.lovable.app/ideas/games-sponsored-xr-exhibits-17

Build "Sponsored XR Exhibits" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Host XR galleries that visitors explore with gasless wallet login and sponsored interaction tx.
Discipline: Game Design & Interactive Media (virtual galleries). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a virtual galleries action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The virtual galleries flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA games-privy-crafting-market-18 · Base · Privy Crafting Market =====
Page: https://arcprompts.lovable.app/ideas/games-privy-crafting-market-18

Build "Privy Crafting Market" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Trade crafted game items with gasless wallet sign-in and sponsored trades.
Discipline: Game Design & Interactive Media (player economies). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a player economies action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The player economies flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA games-gasless-streaming-rewards-19 · Base · Gasless Streaming Rewards =====
Page: https://arcprompts.lovable.app/ideas/games-gasless-streaming-rewards-19

Build "Gasless Streaming Rewards" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Reward game stream viewers with gas-free wallet transactions sponsored by creators.
Discipline: Game Design & Interactive Media (viewer incentives). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a viewer incentives action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The viewer incentives flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA games-sponsored-fan-tokens-20 · Base · Sponsored Fan Tokens =====
Page: https://arcprompts.lovable.app/ideas/games-sponsored-fan-tokens-20

Build "Sponsored Fan Tokens" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Issue fan engagement tokens to gamers using gasless wallet onboarding and sponsored mints.
Discipline: Game Design & Interactive Media (community engagement). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a community engagement action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The community engagement flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA games-privy-challenge-leaderboards-21 · Base · Privy Challenge Leaderboards =====
Page: https://arcprompts.lovable.app/ideas/games-privy-challenge-leaderboards-21

Build "Privy Challenge Leaderboards" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Track daily challenges and leaderboards with gasless wallet logins and sponsored updates.
Discipline: Game Design & Interactive Media (competitive tracking). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a competitive tracking action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The competitive tracking flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA games-gas-free-level-sharing-22 · Base · Gas-Free Level Sharing =====
Page: https://arcprompts.lovable.app/ideas/games-gas-free-level-sharing-22

Build "Gas-Free Level Sharing" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Share custom levels with friends through gasless wallet sign-in and sponsored access transactions.
Discipline: Game Design & Interactive Media (user content). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a user content action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The user content flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA games-sponsored-multiplayer-drops-23 · Base · Sponsored Multiplayer Drops =====
Page: https://arcprompts.lovable.app/ideas/games-sponsored-multiplayer-drops-23

Build "Sponsored Multiplayer Drops" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Distribute gasless event drops during multiplayer games with embedded wallets and sponsored tx.
Discipline: Game Design & Interactive Media (event rewards). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a event rewards action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The event rewards flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA games-privy-interactive-ads-24 · Base · Privy Interactive Ads =====
Page: https://arcprompts.lovable.app/ideas/games-privy-interactive-ads-24

Build "Privy Interactive Ads" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Engage users with interactive ads that deliver gasless rewards via embedded wallets.
Discipline: Game Design & Interactive Media (ad integration). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a ad integration action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The ad integration flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA games-provenance-playbooks-0 · Base · Provenance Playbooks =====
Page: https://arcprompts.lovable.app/ideas/games-provenance-playbooks-0

Build "Provenance Playbooks" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Create branching story games with verifiable original story assets minted onchain.
Discipline: Game Design & Interactive Media (game narrative design). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a game narrative design work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The game narrative design flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA games-pixel-provenance-1 · Base · Pixel Provenance =====
Page: https://arcprompts.lovable.app/ideas/games-pixel-provenance-1

Build "Pixel Provenance" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint and verify original pixel art sprites as unique NFTs for games and assets.
Discipline: Game Design & Interactive Media (pixel art creation). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a pixel art creation work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The pixel art creation flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA games-sound-slice-chain-2 · Base · Sound Slice Chain =====
Page: https://arcprompts.lovable.app/ideas/games-sound-slice-chain-2

Build "Sound Slice Chain" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Securely mint and track original sound samples for interactive game soundtracks.
Discipline: Game Design & Interactive Media (game audio sampling). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a game audio sampling work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The game audio sampling flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA games-vr-provenance-hub-3 · Base · VR Provenance Hub =====
Page: https://arcprompts.lovable.app/ideas/games-vr-provenance-hub-3

Build "VR Provenance Hub" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint immersive VR environments as NFTs to ensure creator authenticity and ownership.
Discipline: Game Design & Interactive Media (XR environment design). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a XR environment design work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The XR environment design flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA games-avatar-dna-chain-4 · Base · Avatar DNA Chain =====
Page: https://arcprompts.lovable.app/ideas/games-avatar-dna-chain-4

Build "Avatar DNA Chain" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Create unique avatars with provenance-tracked traits minted as ERC-721 tokens.
Discipline: Game Design & Interactive Media (custom avatar creation). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a custom avatar creation work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The custom avatar creation flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA games-procedural-provenance-5 · Base · Procedural Provenance =====
Page: https://arcprompts.lovable.app/ideas/games-procedural-provenance-5

Build "Procedural Provenance" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint procedurally generated game art as NFTs linked to creator algorithms onchain.
Discipline: Game Design & Interactive Media (algorithmic game art). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a algorithmic game art work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The algorithmic game art flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA games-interactive-comics-chain-6 · Base · Interactive Comics Chain =====
Page: https://arcprompts.lovable.app/ideas/games-interactive-comics-chain-6

Build "Interactive Comics Chain" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Securely mint interactive comic panels as unique NFTs with onchain provenance.
Discipline: Game Design & Interactive Media (interactive storytelling). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a interactive storytelling work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The interactive storytelling flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA games-game-mod-provenance-7 · Base · Game Mod Provenance =====
Page: https://arcprompts.lovable.app/ideas/games-game-mod-provenance-7

Build "Game Mod Provenance" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint unique game mods with provenance to authenticate original creator contributions.
Discipline: Game Design & Interactive Media (modding community tools). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a modding community tools work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The modding community tools flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA games-level-chain-creator-8 · Base · Level Chain Creator =====
Page: https://arcprompts.lovable.app/ideas/games-level-chain-creator-8

Build "Level Chain Creator" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint custom game levels as NFTs with proof of originality and ownership onchain.
Discipline: Game Design & Interactive Media (game level design). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a game level design work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The game level design flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA games-replay-provenance-9 · Base · Replay Provenance =====
Page: https://arcprompts.lovable.app/ideas/games-replay-provenance-9

Build "Replay Provenance" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint verified game replays as NFTs to prove originality and preserve gameplay moments.
Discipline: Game Design & Interactive Media (game replay sharing). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a game replay sharing work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The game replay sharing flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA games-xr-gesture-tokens-10 · Base · XR Gesture Tokens =====
Page: https://arcprompts.lovable.app/ideas/games-xr-gesture-tokens-10

Build "XR Gesture Tokens" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint original XR gesture captures as NFTs proving creator authorship.
Discipline: Game Design & Interactive Media (motion capture NFTs). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a motion capture NFTs work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The motion capture NFTs flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA games-lore-chain-artifacts-11 · Base · Lore Chain Artifacts =====
Page: https://arcprompts.lovable.app/ideas/games-lore-chain-artifacts-11

Build "Lore Chain Artifacts" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint in-game lore entries as NFTs to guarantee original creation and provenance.
Discipline: Game Design & Interactive Media (game lore documentation). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a game lore documentation work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The game lore documentation flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA games-ar-filter-provenance-12 · Base · AR Filter Provenance =====
Page: https://arcprompts.lovable.app/ideas/games-ar-filter-provenance-12

Build "AR Filter Provenance" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Create and mint AR filters as NFTs ensuring verified creator ownership.
Discipline: Game Design & Interactive Media (augmented reality effects). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a augmented reality effects work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The augmented reality effects flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA games-interactive-music-nfts-13 · Base · Interactive Music NFTs =====
Page: https://arcprompts.lovable.app/ideas/games-interactive-music-nfts-13

Build "Interactive Music NFTs" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint unique interactive game soundtrack remixes with onchain provenance.
Discipline: Game Design & Interactive Media (game soundtrack remixing). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a game soundtrack remixing work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The game soundtrack remixing flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA games-tokenized-game-guides-14 · Base · Tokenized Game Guides =====
Page: https://arcprompts.lovable.app/ideas/games-tokenized-game-guides-14

Build "Tokenized Game Guides" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint original game strategy guides as NFTs to prove and reward authorship.
Discipline: Game Design & Interactive Media (strategy content). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a strategy content work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The strategy content flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA games-dynamic-npc-tokens-15 · Base · Dynamic NPC Tokens =====
Page: https://arcprompts.lovable.app/ideas/games-dynamic-npc-tokens-15

Build "Dynamic NPC Tokens" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint dynamic NPCs as NFTs with provable creator-generated traits and backstories.
Discipline: Game Design & Interactive Media (procedural character design). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a procedural character design work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The procedural character design flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA games-haptic-asset-chain-16 · Base · Haptic Asset Chain =====
Page: https://arcprompts.lovable.app/ideas/games-haptic-asset-chain-16

Build "Haptic Asset Chain" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint original haptic feedback patterns for XR as provenance-verified NFTs.
Discipline: Game Design & Interactive Media (tactile feedback design). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a tactile feedback design work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The tactile feedback design flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA games-ai-art-provenance-17 · Base · AI Art Provenance =====
Page: https://arcprompts.lovable.app/ideas/games-ai-art-provenance-17

Build "AI Art Provenance" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint AI-generated game art NFTs with provenance proving creator guidance originality.
Discipline: Game Design & Interactive Media (AI-generated game art). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a AI-generated game art work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The AI-generated game art flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA games-multiplayer-skin-chain-18 · Base · Multiplayer Skin Chain =====
Page: https://arcprompts.lovable.app/ideas/games-multiplayer-skin-chain-18

Build "Multiplayer Skin Chain" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint unique multiplayer game skins as NFTs with verifiable creator provenance.
Discipline: Game Design & Interactive Media (cosmetic item creation). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a cosmetic item creation work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The cosmetic item creation flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA games-puzzle-chain-creator-19 · Base · Puzzle Chain Creator =====
Page: https://arcprompts.lovable.app/ideas/games-puzzle-chain-creator-19

Build "Puzzle Chain Creator" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint original interactive puzzles as NFTs proving unique creator ownership.
Discipline: Game Design & Interactive Media (interactive puzzle design). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a interactive puzzle design work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The interactive puzzle design flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA games-narrative-voice-tokens-20 · Base · Narrative Voice Tokens =====
Page: https://arcprompts.lovable.app/ideas/games-narrative-voice-tokens-20

Build "Narrative Voice Tokens" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint original voiceover clips for games as provenance-verified NFTs.
Discipline: Game Design & Interactive Media (voice acting assets). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a voice acting assets work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The voice acting assets flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA games-interactive-map-nfts-21 · Base · Interactive Map NFTs =====
Page: https://arcprompts.lovable.app/ideas/games-interactive-map-nfts-21

Build "Interactive Map NFTs" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint original interactive game maps as NFTs with verified creator provenance.
Discipline: Game Design & Interactive Media (game world mapping). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a game world mapping work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The game world mapping flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA games-collectible-lore-cards-22 · Base · Collectible Lore Cards =====
Page: https://arcprompts.lovable.app/ideas/games-collectible-lore-cards-22

Build "Collectible Lore Cards" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint unique lore cards as NFTs proving authentic creator provenance.
Discipline: Game Design & Interactive Media (digital collectible design). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a digital collectible design work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The digital collectible design flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA games-gesture-control-assets-23 · Base · Gesture-Control Assets =====
Page: https://arcprompts.lovable.app/ideas/games-gesture-control-assets-23

Build "Gesture-Control Assets" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint unique XR gesture control assets as NFTs ensuring original creator rights.
Discipline: Game Design & Interactive Media (XR gesture interaction). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a XR gesture interaction work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The XR gesture interaction flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA games-game-font-provenance-24 · Base · Game Font Provenance =====
Page: https://arcprompts.lovable.app/ideas/games-game-font-provenance-24

Build "Game Font Provenance" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint unique game fonts as NFTs proving original designer ownership.
Discipline: Game Design & Interactive Media (typography for games). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a typography for games work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The typography for games flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA theater-scriptchain-ledger-0 · Base · ScriptChain Ledger =====
Page: https://arcprompts.lovable.app/ideas/theater-scriptchain-ledger-0

Build "ScriptChain Ledger" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Securely track and timestamp script drafts through an immutable blockchain ledger.
Discipline: Theater & Live Performance (playwright collaboration). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a playwright collaboration item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The playwright collaboration flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA theater-roleauction-platform-1 · Base · RoleAuction Platform =====
Page: https://arcprompts.lovable.app/ideas/theater-roleauction-platform-1

Build "RoleAuction Platform" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Decentralized audition bids let performers compete transparently for roles via smart contracts.
Discipline: Theater & Live Performance (casting marketplace). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a casting marketplace item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The casting marketplace flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA theater-stagelight-token-2 · Base · StageLight Token =====
Page: https://arcprompts.lovable.app/ideas/theater-stagelight-token-2

Build "StageLight Token" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Issue and trade usage rights for lighting designs using onchain tokens to protect creators.
Discipline: Theater & Live Performance (lighting rights management). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a lighting rights management item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The lighting rights management flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA theater-promptchain-impro-3 · Base · PromptChain Impro =====
Page: https://arcprompts.lovable.app/ideas/theater-promptchain-impro-3

Build "PromptChain Impro" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Generate and track custom improv prompts securely stored and shared via smart contracts.
Discipline: Theater & Live Performance (improvisation prompts). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a improvisation prompts item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The improvisation prompts flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA theater-tickettrust-nft-4 · Base · TicketTrust NFT =====
Page: https://arcprompts.lovable.app/ideas/theater-tickettrust-nft-4

Build "TicketTrust NFT" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Use blockchain to mint tamper-proof NFT tickets preventing counterfeiting for live performances.
Discipline: Theater & Live Performance (ticket authenticity). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a ticket authenticity item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The ticket authenticity flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA theater-propchain-registry-5 · Base · PropChain Registry =====
Page: https://arcprompts.lovable.app/ideas/theater-propchain-registry-5

Build "PropChain Registry" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Record and transfer ownership history of stage props transparently on a blockchain registry.
Discipline: Theater & Live Performance (prop ownership). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a prop ownership item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The prop ownership flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA theater-scriptroyalty-split-6 · Base · ScriptRoyalty Split =====
Page: https://arcprompts.lovable.app/ideas/theater-scriptroyalty-split-6

Build "ScriptRoyalty Split" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Automate fair payouts to playwrights, directors, and actors using onchain royalty splits.
Discipline: Theater & Live Performance (royalty distribution). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a royalty distribution item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The royalty distribution flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA theater-stagecrew-dao-7 · Base · StageCrew DAO =====
Page: https://arcprompts.lovable.app/ideas/theater-stagecrew-dao-7

Build "StageCrew DAO" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Decentralize stage crew decisions and resource allocation through a transparent DAO governed by smart contracts.
Discipline: Theater & Live Performance (crew coordination). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a crew coordination item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The crew coordination flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA theater-playmint-nft-8 · Base · PlayMint NFT =====
Page: https://arcprompts.lovable.app/ideas/theater-playmint-nft-8

Build "PlayMint NFT" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint unique digital editions of scripts as NFTs to protect intellectual property and track sales.
Discipline: Theater & Live Performance (script NFTs). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a script NFTs item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The script NFTs flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA theater-actorstake-platform-9 · Base · ActorStake Platform =====
Page: https://arcprompts.lovable.app/ideas/theater-actorstake-platform-9

Build "ActorStake Platform" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Allow fans to stake tokens on actors’ performances, rewarding success with blockchain incentives.
Discipline: Theater & Live Performance (performance staking). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a performance staking item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The performance staking flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA theater-lightcue-automation-10 · Base · LightCue Automation =====
Page: https://arcprompts.lovable.app/ideas/theater-lightcue-automation-10

Build "LightCue Automation" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Record and trigger lighting cues onchain to verify show timing and enable automated playback.
Discipline: Theater & Live Performance (lighting cue logs). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a lighting cue logs item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The lighting cue logs flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA theater-scenechange-nfts-11 · Base · SceneChange NFTs =====
Page: https://arcprompts.lovable.app/ideas/theater-scenechange-nfts-11

Build "SceneChange NFTs" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Artists mint NFT certificates of original scene designs for resale and licensing.
Discipline: Theater & Live Performance (scene ownership). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a scene ownership item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The scene ownership flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA theater-playbill-ledger-12 · Base · Playbill Ledger =====
Page: https://arcprompts.lovable.app/ideas/theater-playbill-ledger-12

Build "Playbill Ledger" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Securely record production credits and changes transparently on a public ledger.
Discipline: Theater & Live Performance (production documentation). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a production documentation item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The production documentation flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA theater-audiencevote-dao-13 · Base · AudienceVote DAO =====
Page: https://arcprompts.lovable.app/ideas/theater-audiencevote-dao-13

Build "AudienceVote DAO" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Collect and tally audience votes on performances in a transparent, tamper-proof DAO system.
Discipline: Theater & Live Performance (live feedback). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a live feedback item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The live feedback flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA theater-backstage-token-14 · Base · Backstage Token =====
Page: https://arcprompts.lovable.app/ideas/theater-backstage-token-14

Build "Backstage Token" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Issue tokens granting secure, onchain backstage access for staff and VIPs.
Discipline: Theater & Live Performance (access control). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a access control item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The access control flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA theater-rehearsallog-chain-15 · Base · RehearsalLog Chain =====
Page: https://arcprompts.lovable.app/ideas/theater-rehearsallog-chain-15

Build "RehearsalLog Chain" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Immutably store rehearsal attendance and notes to improve production accountability.
Discipline: Theater & Live Performance (rehearsal tracking). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a rehearsal tracking item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The rehearsal tracking flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA theater-scriptlens-dao-16 · Base · ScriptLens DAO =====
Page: https://arcprompts.lovable.app/ideas/theater-scriptlens-dao-16

Build "ScriptLens DAO" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Enable playwrights and directors to co-own scripts via decentralized governance and revenue sharing.
Discipline: Theater & Live Performance (script co-creation). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a script co-creation item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The script co-creation flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA theater-sceneswap-marketplace-17 · Base · SceneSwap Marketplace =====
Page: https://arcprompts.lovable.app/ideas/theater-sceneswap-marketplace-17

Build "SceneSwap Marketplace" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Trade and license scene and set designs through a verified onchain marketplace.
Discipline: Theater & Live Performance (design exchange). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a design exchange item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The design exchange flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA theater-performerbadge-nft-18 · Base · PerformerBadge NFT =====
Page: https://arcprompts.lovable.app/ideas/theater-performerbadge-nft-18

Build "PerformerBadge NFT" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint verifiable NFT badges certifying performer skills and achievements.
Discipline: Theater & Live Performance (credentials verification). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a credentials verification item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The credentials verification flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA theater-lightfx-tokenize-19 · Base · LightFX Tokenize =====
Page: https://arcprompts.lovable.app/ideas/theater-lightfx-tokenize-19

Build "LightFX Tokenize" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Tokenize and license stage special effects designs to productions worldwide securely.
Discipline: Theater & Live Performance (special effects licensing). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a special effects licensing item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The special effects licensing flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA theater-caststake-dao-20 · Base · CastStake DAO =====
Page: https://arcprompts.lovable.app/ideas/theater-caststake-dao-20

Build "CastStake DAO" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Decentralize theater production funding by letting stakeholders vote and invest through DAO tokens.
Discipline: Theater & Live Performance (fundraising). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a fundraising item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The fundraising flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA theater-propstoken-swap-21 · Base · PropsToken Swap =====
Page: https://arcprompts.lovable.app/ideas/theater-propstoken-swap-21

Build "PropsToken Swap" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Create a tokenized system for lending and borrowing props between theater companies.
Discipline: Theater & Live Performance (collaborative prop lending). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a collaborative prop lending item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The collaborative prop lending flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA theater-stagesound-dao-22 · Base · StageSound DAO =====
Page: https://arcprompts.lovable.app/ideas/theater-stagesound-dao-22

Build "StageSound DAO" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Coordinate and monetize collective sound design projects with transparent DAOs and revenue splits.
Discipline: Theater & Live Performance (sound design collaboration). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a sound design collaboration item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The sound design collaboration flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA theater-encore-reward-23 · Base · Encore Reward =====
Page: https://arcprompts.lovable.app/ideas/theater-encore-reward-23

Build "Encore Reward" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Tokenize audience rewards to incentivize repeat attendance and engagement at live performances.
Discipline: Theater & Live Performance (audience loyalty). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a audience loyalty item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The audience loyalty flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA theater-setpiece-provenance-24 · Base · SetPiece Provenance =====
Page: https://arcprompts.lovable.app/ideas/theater-setpiece-provenance-24

Build "SetPiece Provenance" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Archive and authenticate historical set pieces’ origin and usage on an immutable blockchain record.
Discipline: Theater & Live Performance (historical archival). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a historical archival item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The historical archival flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA theater-stagelight-archive-0 · Base · StageLight Archive =====
Page: https://arcprompts.lovable.app/ideas/theater-stagelight-archive-0

Build "StageLight Archive" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin and access dynamic stage lighting setups with permanent IPFS storage for reliable reuse and sharing.
Discipline: Theater & Live Performance (lighting design). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a lighting design sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The lighting design flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA theater-playscript-vault-1 · Base · PlayScript Vault =====
Page: https://arcprompts.lovable.app/ideas/theater-playscript-vault-1

Build "PlayScript Vault" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Securely save, share, and version play scripts on IPFS to preserve authorship and facilitate collaboration.
Discipline: Theater & Live Performance (playwriting). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a playwriting sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The playwriting flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA theater-costumemood-board-2 · Base · CostumeMood Board =====
Page: https://arcprompts.lovable.app/ideas/theater-costumemood-board-2

Build "CostumeMood Board" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin and share costume sketches and mood boards on IPFS for collaborative costume creation.
Discipline: Theater & Live Performance (costume design). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a costume design sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The costume design flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA theater-actorportfolio-hub-3 · Base · ActorPortfolio Hub =====
Page: https://arcprompts.lovable.app/ideas/theater-actorportfolio-hub-3

Build "ActorPortfolio Hub" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Actors upload and pin portfolios including headshots and performance clips permanently on IPFS for casting accessibility.
Discipline: Theater & Live Performance (performance showcase). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a performance showcase sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The performance showcase flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA theater-setdesign-manifest-4 · Base · SetDesign Manifest =====
Page: https://arcprompts.lovable.app/ideas/theater-setdesign-manifest-4

Build "SetDesign Manifest" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Store and share complex 3D set designs and manifests immutably on IPFS for production coordination.
Discipline: Theater & Live Performance (set design). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a set design sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The set design flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA theater-lightingcues-ledger-5 · Base · LightingCues Ledger =====
Page: https://arcprompts.lovable.app/ideas/theater-lightingcues-ledger-5

Build "LightingCues Ledger" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Save and distribute lighting cue sequences as pinned JSON on IPFS for synchronized performances.
Discipline: Theater & Live Performance (lighting cues). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a lighting cues sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The lighting cues flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA theater-playpromo-kit-6 · Base · PlayPromo Kit =====
Page: https://arcprompts.lovable.app/ideas/theater-playpromo-kit-6

Build "PlayPromo Kit" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin play promo images and metadata on IPFS to ensure immutable, globally accessible marketing assets.
Discipline: Theater & Live Performance (marketing collateral). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a marketing collateral sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The marketing collateral flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA theater-scriptrevision-chain-7 · Base · ScriptRevision Chain =====
Page: https://arcprompts.lovable.app/ideas/theater-scriptrevision-chain-7

Build "ScriptRevision Chain" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Immutable version control for script edits stored and shared pinned on IPFS for playwrights and directors.
Discipline: Theater & Live Performance (script editing). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a script editing sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The script editing flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA theater-setprops-catalog-8 · Base · SetProps Catalog =====
Page: https://arcprompts.lovable.app/ideas/theater-setprops-catalog-8

Build "SetProps Catalog" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin and index prop images and descriptions on IPFS for collaborative rental and inventory management.
Discipline: Theater & Live Performance (props management). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a props management sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The props management flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA theater-soundscape-archive-9 · Base · Soundscape Archive =====
Page: https://arcprompts.lovable.app/ideas/theater-soundscape-archive-9

Build "Soundscape Archive" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin ambient and effect sound files with metadata on IPFS to ensure lasting availability and sharing.
Discipline: Theater & Live Performance (sound design). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a sound design sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The sound design flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA theater-performancereview-ledger-10 · Base · PerformanceReview Ledger =====
Page: https://arcprompts.lovable.app/ideas/theater-performancereview-ledger-10

Build "PerformanceReview Ledger" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Store aggregated audience reviews as pinned JSON on IPFS guaranteeing unalterable feedback records.
Discipline: Theater & Live Performance (audience feedback). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a audience feedback sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The audience feedback flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA theater-lightingpalette-exchange-11 · Base · LightingPalette Exchange =====
Page: https://arcprompts.lovable.app/ideas/theater-lightingpalette-exchange-11

Build "LightingPalette Exchange" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin and trade curated lighting color palettes as images and data on IPFS for designers to reuse.
Discipline: Theater & Live Performance (color study). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a color study sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The color study flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA theater-venuemap-index-12 · Base · VenueMap Index =====
Page: https://arcprompts.lovable.app/ideas/theater-venuemap-index-12

Build "VenueMap Index" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin detailed venue and stage layout manifests on IPFS for directors and designers to coordinate setups.
Discipline: Theater & Live Performance (stage layout). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a stage layout sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The stage layout flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA theater-monologue-archive-13 · Base · Monologue Archive =====
Page: https://arcprompts.lovable.app/ideas/theater-monologue-archive-13

Build "Monologue Archive" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin curated monologue scripts and performance notes on IPFS preserving artistic intent unchangeably.
Discipline: Theater & Live Performance (performance repertoire). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a performance repertoire sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The performance repertoire flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA theater-costumetexture-bank-14 · Base · CostumeTexture Bank =====
Page: https://arcprompts.lovable.app/ideas/theater-costumetexture-bank-14

Build "CostumeTexture Bank" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin high-resolution fabric texture images and details on IPFS for costume designers’ resource sharing.
Discipline: Theater & Live Performance (fabric study). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a fabric study sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The fabric study flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA theater-propblueprint-cache-15 · Base · PropBlueprint Cache =====
Page: https://arcprompts.lovable.app/ideas/theater-propblueprint-cache-15

Build "PropBlueprint Cache" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Store and share detailed prop blueprints and assembly guides pinned immutably on IPFS for artisans.
Discipline: Theater & Live Performance (prop design). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a prop design sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The prop design flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA theater-directorstoryboard-hub-16 · Base · DirectorStoryboard Hub =====
Page: https://arcprompts.lovable.app/ideas/theater-directorstoryboard-hub-16

Build "DirectorStoryboard Hub" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin storyboards as image sequences on IPFS to maintain integrity and facilitate collaboration across teams.
Discipline: Theater & Live Performance (storyboarding). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a storyboarding sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The storyboarding flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA theater-lightingfixture-db-17 · Base · LightingFixture DB =====
Page: https://arcprompts.lovable.app/ideas/theater-lightingfixture-db-17

Build "LightingFixture DB" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin detailed lighting fixture profiles and manuals on IPFS for technicians and designers to access anytime.
Discipline: Theater & Live Performance (equipment catalog). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a equipment catalog sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The equipment catalog flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA theater-virtualstage-seeds-18 · Base · VirtualStage Seeds =====
Page: https://arcprompts.lovable.app/ideas/theater-virtualstage-seeds-18

Build "VirtualStage Seeds" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin virtual stage assets and scene manifests on IPFS for seamless integration in live and hybrid performances.
Discipline: Theater & Live Performance (virtual set design). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a virtual set design sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The virtual set design flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA theater-lightingpattern-archive-19 · Base · LightingPattern Archive =====
Page: https://arcprompts.lovable.app/ideas/theater-lightingpattern-archive-19

Build "LightingPattern Archive" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin and share choreographed lighting patterns and sequences immutably on IPFS for repeatable productions.
Discipline: Theater & Live Performance (lighting choreography). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a lighting choreography sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The lighting choreography flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA theater-performancemanifesto-20 · Base · PerformanceManifesto =====
Page: https://arcprompts.lovable.app/ideas/theater-performancemanifesto-20

Build "PerformanceManifesto" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin performance manifestos and artistic statements as permanent JSON files on IPFS for posterity and access.
Discipline: Theater & Live Performance (creative documentation). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a creative documentation sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The creative documentation flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA theater-stagesafety-logs-21 · Base · StageSafety Logs =====
Page: https://arcprompts.lovable.app/ideas/theater-stagesafety-logs-21

Build "StageSafety Logs" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin safety inspection reports and compliance logs on IPFS ensuring tamper-proof records for venues and crews.
Discipline: Theater & Live Performance (safety compliance). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a safety compliance sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The safety compliance flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA theater-actorlinetracker-22 · Base · ActorLineTracker =====
Page: https://arcprompts.lovable.app/ideas/theater-actorlinetracker-22

Build "ActorLineTracker" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin annotated lines and rehearsal notes as immutable JSON to IPFS for actors’ reliable study aids.
Discipline: Theater & Live Performance (line memorization). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a line memorization sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The line memorization flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA theater-setlighting-simulator-23 · Base · SetLighting Simulator =====
Page: https://arcprompts.lovable.app/ideas/theater-setlighting-simulator-23

Build "SetLighting Simulator" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin lighting simulation data and images on IPFS for real-time, distributed production previews.
Discipline: Theater & Live Performance (previsualization). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a previsualization sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The previsualization flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA theater-playbill-archive-24 · Base · PlayBill Archive =====
Page: https://arcprompts.lovable.app/ideas/theater-playbill-archive-24

Build "PlayBill Archive" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin historic and current playbill designs on IPFS for theatrical heritage and design reference.
Discipline: Theater & Live Performance (program design). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a program design sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The program design flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA theater-smartstage-access-0 · Base · SmartStage Access =====
Page: https://arcprompts.lovable.app/ideas/theater-smartstage-access-0

Build "SmartStage Access" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Enable seamless, gas-free ticketing and VIP experiences via social login and sponsored transactions.
Discipline: Theater & Live Performance (audience engagement). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a audience engagement action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The audience engagement flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA theater-scriptshare-vault-1 · Base · ScriptShare Vault =====
Page: https://arcprompts.lovable.app/ideas/theater-scriptshare-vault-1

Build "ScriptShare Vault" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Facilitate secure, collaborative script revisions with onchain identity and no-fee transactions.
Discipline: Theater & Live Performance (script collaboration). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a script collaboration action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The script collaboration flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA theater-propchain-ledger-2 · Base · PropChain Ledger =====
Page: https://arcprompts.lovable.app/ideas/theater-propchain-ledger-2

Build "PropChain Ledger" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Track and verify theater prop history and ownership with private social access and free transactions.
Discipline: Theater & Live Performance (prop provenance). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a prop provenance action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The prop provenance flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA theater-lightcue-sync-3 · Base · LightCue Sync =====
Page: https://arcprompts.lovable.app/ideas/theater-lightcue-sync-3

Build "LightCue Sync" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Collaborate on lighting cues live with instant, gasless onchain updates through social login.
Discipline: Theater & Live Performance (lighting design). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a lighting design action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The lighting design flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA theater-actortrust-ledger-4 · Base · ActorTrust Ledger =====
Page: https://arcprompts.lovable.app/ideas/theater-actortrust-ledger-4

Build "ActorTrust Ledger" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Store and verify actor resumes and roles securely with social login and no gas fees.
Discipline: Theater & Live Performance (performance credentials). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a performance credentials action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The performance credentials flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA theater-sceneswap-marketplace-5 · Base · SceneSwap Marketplace =====
Page: https://arcprompts.lovable.app/ideas/theater-sceneswap-marketplace-5

Build "SceneSwap Marketplace" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Enable gas-free peer-to-peer trading of set designs via social wallet and sponsored tx.
Discipline: Theater & Live Performance (set design exchange). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a set design exchange action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The set design exchange flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA theater-playbill-nfts-6 · Base · Playbill NFTs =====
Page: https://arcprompts.lovable.app/ideas/theater-playbill-nfts-6

Build "Playbill NFTs" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Create and distribute collectible digital playbills with embedded social wallet and free minting.
Discipline: Theater & Live Performance (memorabilia). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a memorabilia action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The memorabilia flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA theater-audiencevote-live-7 · Base · AudienceVote Live =====
Page: https://arcprompts.lovable.app/ideas/theater-audiencevote-live-7

Build "AudienceVote Live" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Let audiences vote live on performance elements using social login and gasless onchain votes.
Discipline: Theater & Live Performance (interactive performances). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a interactive performances action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The interactive performances flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA theater-backstage-pass-8 · Base · Backstage Pass =====
Page: https://arcprompts.lovable.app/ideas/theater-backstage-pass-8

Build "Backstage Pass" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Offer backstage digital passes with seamless social wallet login and free sponsorship tx.
Discipline: Theater & Live Performance (exclusive access). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a exclusive access action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The exclusive access flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA theater-rehearsalrecord-9 · Base · RehearsalRecord =====
Page: https://arcprompts.lovable.app/ideas/theater-rehearsalrecord-9

Build "RehearsalRecord" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Securely archive rehearsal footage and notes with social wallet authentication and free updates.
Discipline: Theater & Live Performance (performance archives). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a performance archives action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The performance archives flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA theater-sponsorspotlight-10 · Base · SponsorSpotlight =====
Page: https://arcprompts.lovable.app/ideas/theater-sponsorspotlight-10

Build "SponsorSpotlight" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Connect sponsors and shows with onchain contracts signed via social login and no gas fees.
Discipline: Theater & Live Performance (performance sponsorship). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a performance sponsorship action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The performance sponsorship flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA theater-roleswap-network-11 · Base · RoleSwap Network =====
Page: https://arcprompts.lovable.app/ideas/theater-roleswap-network-11

Build "RoleSwap Network" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Facilitate secure actor role exchanges and confirmations with social wallets and sponsored transactions.
Discipline: Theater & Live Performance (cast management). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a cast management action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The cast management flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA theater-stagedesign-dao-12 · Base · StageDesign DAO =====
Page: https://arcprompts.lovable.app/ideas/theater-stagedesign-dao-12

Build "StageDesign DAO" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Create decentralized design collectives with gasless voting and social wallet onboarding.
Discipline: Theater & Live Performance (design collaboration). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a design collaboration action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The design collaboration flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA theater-scripttoken-rights-13 · Base · ScriptToken Rights =====
Page: https://arcprompts.lovable.app/ideas/theater-scripttoken-rights-13

Build "ScriptToken Rights" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Manage and transfer script rights securely via social wallet and sponsored onchain transactions.
Discipline: Theater & Live Performance (rights management). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a rights management action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The rights management flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA theater-cuepoint-tracker-14 · Base · CuePoint Tracker =====
Page: https://arcprompts.lovable.app/ideas/theater-cuepoint-tracker-14

Build "CuePoint Tracker" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Provide directors with gasless onchain cue tracking and adjustments via social login.
Discipline: Theater & Live Performance (live direction). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a live direction action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The live direction flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA theater-actormint-ledger-15 · Base · ActorMint Ledger =====
Page: https://arcprompts.lovable.app/ideas/theater-actormint-ledger-15

Build "ActorMint Ledger" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint and distribute unique actor NFTs representing roles and performances with gasless minting.
Discipline: Theater & Live Performance (performance NFTs). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a performance NFTs action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The performance NFTs flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA theater-setbuild-contracts-16 · Base · SetBuild Contracts =====
Page: https://arcprompts.lovable.app/ideas/theater-setbuild-contracts-16

Build "SetBuild Contracts" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Automate set construction contracts with social wallet signing and no-fee onchain transactions.
Discipline: Theater & Live Performance (production agreements). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a production agreements action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The production agreements flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA theater-lightingtoken-rewards-17 · Base · LightingToken Rewards =====
Page: https://arcprompts.lovable.app/ideas/theater-lightingtoken-rewards-17

Build "LightingToken Rewards" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Issue tokenized rewards to lighting crews with social wallet onboarding and sponsored tx.
Discipline: Theater & Live Performance (crew incentives). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a crew incentives action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The crew incentives flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA theater-playwright-guild-18 · Base · Playwright Guild =====
Page: https://arcprompts.lovable.app/ideas/theater-playwright-guild-18

Build "Playwright Guild" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Create tokenized playwright guilds with seamless social login and gasless member transactions.
Discipline: Theater & Live Performance (community membership). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a community membership action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The community membership flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA theater-audiencetip-jar-19 · Base · AudienceTip Jar =====
Page: https://arcprompts.lovable.app/ideas/theater-audiencetip-jar-19

Build "AudienceTip Jar" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Let audiences tip performers instantly with social wallets and sponsored transaction gaslessness.
Discipline: Theater & Live Performance (fan monetization). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a fan monetization action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The fan monetization flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA theater-promochain-posters-20 · Base · PromoChain Posters =====
Page: https://arcprompts.lovable.app/ideas/theater-promochain-posters-20

Build "PromoChain Posters" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Distribute limited-edition promo posters as NFTs with easy social wallet minting and free tx.
Discipline: Theater & Live Performance (marketing assets). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a marketing assets action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The marketing assets flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA theater-scriptarchive-dao-21 · Base · ScriptArchive DAO =====
Page: https://arcprompts.lovable.app/ideas/theater-scriptarchive-dao-21

Build "ScriptArchive DAO" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Preserve scripts onchain with collaborative DAO management and gasless transactions via social wallets.
Discipline: Theater & Live Performance (preservation). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a preservation action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The preservation flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA theater-virtualstage-access-22 · Base · VirtualStage Access =====
Page: https://arcprompts.lovable.app/ideas/theater-virtualstage-access-22

Build "VirtualStage Access" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Grant gasless access to hybrid live/virtual shows via social wallet login and sponsored tx.
Discipline: Theater & Live Performance (hybrid performances). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a hybrid performances action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The hybrid performances flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA theater-critiquechain-feedback-23 · Base · CritiqueChain Feedback =====
Page: https://arcprompts.lovable.app/ideas/theater-critiquechain-feedback-23

Build "CritiqueChain Feedback" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Collect verified audience critiques onchain with social login and no-fee feedback transactions.
Discipline: Theater & Live Performance (performance reviews). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a performance reviews action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The performance reviews flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA theater-setinventory-nfts-24 · Base · SetInventory NFTs =====
Page: https://arcprompts.lovable.app/ideas/theater-setinventory-nfts-24

Build "SetInventory NFTs" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Tokenize set inventory for easy rental and ownership tracking with social wallets and free tx.
Discipline: Theater & Live Performance (asset tokenization). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a asset tokenization action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The asset tokenization flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA theater-scene-script-provenance-0 · Base · Scene Script Provenance =====
Page: https://arcprompts.lovable.app/ideas/theater-scene-script-provenance-0

Build "Scene Script Provenance" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Securely mint and track original play scripts as creator-owned NFTs.
Discipline: Theater & Live Performance (playwriting). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a playwriting work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The playwriting flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA theater-lighting-cue-chain-1 · Base · Lighting Cue Chain =====
Page: https://arcprompts.lovable.app/ideas/theater-lighting-cue-chain-1

Build "Lighting Cue Chain" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Record and verify lighting cue sequences as unique NFTs for live performances.
Discipline: Theater & Live Performance (lighting design). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a lighting design work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The lighting design flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA theater-actor-rehearsal-logs-2 · Base · Actor Rehearsal Logs =====
Page: https://arcprompts.lovable.app/ideas/theater-actor-rehearsal-logs-2

Build "Actor Rehearsal Logs" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Actors mint daily rehearsal videos as NFTs to prove practice and progress.
Discipline: Theater & Live Performance (performance tracking). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a performance tracking work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The performance tracking flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA theater-set-design-archives-3 · Base · Set Design Archives =====
Page: https://arcprompts.lovable.app/ideas/theater-set-design-archives-3

Build "Set Design Archives" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint 3D set designs as NFTs for secure sharing and historical provenance.
Discipline: Theater & Live Performance (scenic design). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a scenic design work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The scenic design flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA theater-playwright-feedback-chain-4 · Base · Playwright Feedback Chain =====
Page: https://arcprompts.lovable.app/ideas/theater-playwright-feedback-chain-4

Build "Playwright Feedback Chain" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint feedback and revisions on scripts as NFTs for transparent version control.
Discipline: Theater & Live Performance (script development). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a script development work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The script development flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA theater-performance-nft-tickets-5 · Base · Performance NFT Tickets =====
Page: https://arcprompts.lovable.app/ideas/theater-performance-nft-tickets-5

Build "Performance NFT Tickets" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Issue NFT tickets proving legitimate access and unique attendance experience.
Discipline: Theater & Live Performance (audience engagement). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a audience engagement work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The audience engagement flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA theater-costume-provenance-chain-6 · Base · Costume Provenance Chain =====
Page: https://arcprompts.lovable.app/ideas/theater-costume-provenance-chain-6

Build "Costume Provenance Chain" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint costume designs and ownership as NFTs to protect designer rights and provenance.
Discipline: Theater & Live Performance (costume design). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a costume design work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The costume design flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA theater-monologue-minting-hub-7 · Base · Monologue Minting Hub =====
Page: https://arcprompts.lovable.app/ideas/theater-monologue-minting-hub-7

Build "Monologue Minting Hub" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Actors mint monologues as NFTs to showcase and monetize original performances.
Discipline: Theater & Live Performance (acting). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a acting work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The acting flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA theater-soundscape-provenance-8 · Base · Soundscape Provenance =====
Page: https://arcprompts.lovable.app/ideas/theater-soundscape-provenance-8

Build "Soundscape Provenance" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint live performance soundscapes as NFTs to authenticate original audio environments.
Discipline: Theater & Live Performance (sound design). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a sound design work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The sound design flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA theater-director-s-vision-ledger-9 · Base · Director's Vision Ledger =====
Page: https://arcprompts.lovable.app/ideas/theater-director-s-vision-ledger-9

Build "Director's Vision Ledger" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Directors mint annotated scripts as NFTs capturing their unique vision and notes.
Discipline: Theater & Live Performance (direction). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a direction work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The direction flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA theater-interactive-stage-nfts-10 · Base · Interactive Stage NFTs =====
Page: https://arcprompts.lovable.app/ideas/theater-interactive-stage-nfts-10

Build "Interactive Stage NFTs" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint interactive performance elements as NFTs to prove creative ownership.
Discipline: Theater & Live Performance (stage interaction). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a stage interaction work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The stage interaction flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA theater-improv-moment-mint-11 · Base · Improv Moment Mint =====
Page: https://arcprompts.lovable.app/ideas/theater-improv-moment-mint-11

Build "Improv Moment Mint" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Actors mint spontaneous improv performances as NFTs to preserve unique moments.
Discipline: Theater & Live Performance (improvisation). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a improvisation work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The improvisation flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA theater-choreography-chain-12 · Base · Choreography Chain =====
Page: https://arcprompts.lovable.app/ideas/theater-choreography-chain-12

Build "Choreography Chain" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint choreography sequences as NFTs ensuring original dance and movement rights.
Discipline: Theater & Live Performance (movement design). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a movement design work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The movement design flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA theater-stage-props-provenance-13 · Base · Stage Props Provenance =====
Page: https://arcprompts.lovable.app/ideas/theater-stage-props-provenance-13

Build "Stage Props Provenance" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint digital twins of stage props as NFTs for ownership and rental tracking.
Discipline: Theater & Live Performance (prop management). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a prop management work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The prop management flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA theater-script-translation-nfts-14 · Base · Script Translation NFTs =====
Page: https://arcprompts.lovable.app/ideas/theater-script-translation-nfts-14

Build "Script Translation NFTs" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint translated scripts as NFTs to protect translators' intellectual property.
Discipline: Theater & Live Performance (translation). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a translation work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The translation flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA theater-audience-experience-logs-15 · Base · Audience Experience Logs =====
Page: https://arcprompts.lovable.app/ideas/theater-audience-experience-logs-15

Build "Audience Experience Logs" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint audience reaction recordings as NFTs to capture genuine engagement data.
Discipline: Theater & Live Performance (audience analytics). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a audience analytics work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The audience analytics flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA theater-virtual-backstage-pass-16 · Base · Virtual Backstage Pass =====
Page: https://arcprompts.lovable.app/ideas/theater-virtual-backstage-pass-16

Build "Virtual Backstage Pass" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Issue NFT backstage passes granting exclusive digital and live experience.
Discipline: Theater & Live Performance (fan engagement). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a fan engagement work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The fan engagement flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA theater-playbill-provenance-17 · Base · Playbill Provenance =====
Page: https://arcprompts.lovable.app/ideas/theater-playbill-provenance-17

Build "Playbill Provenance" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint digital playbills as NFTs to preserve historical performance records.
Discipline: Theater & Live Performance (program design). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a program design work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The program design flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA theater-set-lighting-automation-nfts-18 · Base · Set Lighting Automation NFTs =====
Page: https://arcprompts.lovable.app/ideas/theater-set-lighting-automation-nfts-18

Build "Set Lighting Automation NFTs" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint automated lighting sequences as NFTs to secure ownership and resale rights.
Discipline: Theater & Live Performance (lighting tech). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a lighting tech work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The lighting tech flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA theater-drama-therapy-journals-19 · Base · Drama Therapy Journals =====
Page: https://arcprompts.lovable.app/ideas/theater-drama-therapy-journals-19

Build "Drama Therapy Journals" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint personal drama therapy session outputs as NFTs to secure privacy and ownership.
Discipline: Theater & Live Performance (therapeutic performance). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a therapeutic performance work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The therapeutic performance flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA theater-costume-rental-nft-20 · Base · Costume Rental NFT =====
Page: https://arcprompts.lovable.app/ideas/theater-costume-rental-nft-20

Build "Costume Rental NFT" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint NFTs representing costume rental agreements to streamline transactions.
Discipline: Theater & Live Performance (rental services). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a rental services work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The rental services flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA theater-playwright-royalty-nfts-21 · Base · Playwright Royalty NFTs =====
Page: https://arcprompts.lovable.app/ideas/theater-playwright-royalty-nfts-21

Build "Playwright Royalty NFTs" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint royalty shares as NFTs to transparently track playwriting revenue splits.
Discipline: Theater & Live Performance (royalty management). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a royalty management work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The royalty management flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA theater-performance-highlight-reels-22 · Base · Performance Highlight Reels =====
Page: https://arcprompts.lovable.app/ideas/theater-performance-highlight-reels-22

Build "Performance Highlight Reels" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Actors mint highlight reels as NFTs to prove originality and attract bookings.
Discipline: Theater & Live Performance (promotion). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a promotion work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The promotion flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA theater-virtual-set-nfts-23 · Base · Virtual Set NFTs =====
Page: https://arcprompts.lovable.app/ideas/theater-virtual-set-nfts-23

Build "Virtual Set NFTs" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint virtual set designs as NFTs for use in augmented and virtual performances.
Discipline: Theater & Live Performance (digital scenography). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a digital scenography work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The digital scenography flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA theater-script-ownership-registry-24 · Base · Script Ownership Registry =====
Page: https://arcprompts.lovable.app/ideas/theater-script-ownership-registry-24

Build "Script Ownership Registry" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint scripts as NFTs to create an immutable ownership registry for playwrights.
Discipline: Theater & Live Performance (legal protection). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a legal protection work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The legal protection flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA fashion-fabrictrace-ledger-0 · Base · FabricTrace Ledger =====
Page: https://arcprompts.lovable.app/ideas/fashion-fabrictrace-ledger-0

Build "FabricTrace Ledger" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Track and verify organic fabric sources to assure sustainable fashion claims.
Discipline: Fashion & Textile Design (material provenance). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a material provenance item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The material provenance flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA fashion-designauth-mint-1 · Base · DesignAuth Mint =====
Page: https://arcprompts.lovable.app/ideas/fashion-designauth-mint-1

Build "DesignAuth Mint" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Securely register and timestamp original fashion designs to prevent copying.
Discipline: Fashion & Textile Design (design copyright). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a design copyright item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The design copyright flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA fashion-colorpalette-dao-2 · Base · ColorPalette DAO =====
Page: https://arcprompts.lovable.app/ideas/fashion-colorpalette-dao-2

Build "ColorPalette DAO" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Collaboratively create and share color palettes with verified ownership and royalty rules.
Discipline: Fashion & Textile Design (color curation). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a color curation item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The color curation flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA fashion-virtualfitting-nft-3 · Base · VirtualFitting NFT =====
Page: https://arcprompts.lovable.app/ideas/fashion-virtualfitting-nft-3

Build "VirtualFitting NFT" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Create unique virtual fitting sessions minted as NFTs for secure client access.
Discipline: Fashion & Textile Design (virtual try-on). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a virtual try-on item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The virtual try-on flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA fashion-upcycleproof-chain-4 · Base · UpcycleProof Chain =====
Page: https://arcprompts.lovable.app/ideas/fashion-upcycleproof-chain-4

Build "UpcycleProof Chain" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Authenticate recycled textiles’ origin to validate upcycled fashion products.
Discipline: Fashion & Textile Design (recycled textile verification). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a recycled textile verification item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The recycled textile verification flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA fashion-trendsignal-oracles-5 · Base · TrendSignal Oracles =====
Page: https://arcprompts.lovable.app/ideas/fashion-trendsignal-oracles-5

Build "TrendSignal Oracles" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Aggregate verified sales and social data on-chain to predict emerging fashion trends.
Discipline: Fashion & Textile Design (trend prediction). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a trend prediction item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The trend prediction flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA fashion-patternshare-hub-6 · Base · PatternShare Hub =====
Page: https://arcprompts.lovable.app/ideas/fashion-patternshare-hub-6

Build "PatternShare Hub" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
License and trade garment patterns securely using blockchain-based smart contracts.
Discipline: Fashion & Textile Design (pattern licensing). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a pattern licensing item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The pattern licensing flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA fashion-costumenft-archive-7 · Base · CostumeNFT Archive =====
Page: https://arcprompts.lovable.app/ideas/fashion-costumenft-archive-7

Build "CostumeNFT Archive" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Create verified digital archives of historical costumes as NFTs for museums and artists.
Discipline: Fashion & Textile Design (historical costume catalog). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a historical costume catalog item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The historical costume catalog flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA fashion-stylistbooking-chain-8 · Base · StylistBooking Chain =====
Page: https://arcprompts.lovable.app/ideas/fashion-stylistbooking-chain-8

Build "StylistBooking Chain" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Manage stylist-client appointments with transparent, automated escrow and approvals.
Discipline: Fashion & Textile Design (consultation scheduling). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a consultation scheduling item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The consultation scheduling flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA fashion-sustainlabel-verify-9 · Base · SustainLabel Verify =====
Page: https://arcprompts.lovable.app/ideas/fashion-sustainlabel-verify-9

Build "SustainLabel Verify" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Validate sustainable fashion certifications on-chain for trust and transparency.
Discipline: Fashion & Textile Design (eco-label validation). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a eco-label validation item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The eco-label validation flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA fashion-biofiber-token-10 · Base · BioFiber Token =====
Page: https://arcprompts.lovable.app/ideas/fashion-biofiber-token-10

Build "BioFiber Token" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Tokenize biomaterial innovation projects with secure on-chain investment tracking.
Discipline: Fashion & Textile Design (biomaterial crowdfunding). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a biomaterial crowdfunding item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The biomaterial crowdfunding flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA fashion-fashioncollab-dao-11 · Base · FashionCollab DAO =====
Page: https://arcprompts.lovable.app/ideas/fashion-fashioncollab-dao-11

Build "FashionCollab DAO" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Decentralize fashion design collaboration with smart contract governed decision-making.
Discipline: Fashion & Textile Design (collaborative design). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a collaborative design item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The collaborative design flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA fashion-supplychain-mint-12 · Base · SupplyChain Mint =====
Page: https://arcprompts.lovable.app/ideas/fashion-supplychain-mint-12

Build "SupplyChain Mint" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Record each production stage on-chain for transparent garment supply chains.
Discipline: Fashion & Textile Design (production tracking). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a production tracking item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The production tracking flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA fashion-stylelicense-nft-13 · Base · StyleLicense NFT =====
Page: https://arcprompts.lovable.app/ideas/fashion-stylelicense-nft-13

Build "StyleLicense NFT" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint and trade exclusive style licenses as NFTs to protect designer creativity.
Discipline: Fashion & Textile Design (style licensing). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a style licensing item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The style licensing flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA fashion-fabricbatch-chain-14 · Base · FabricBatch Chain =====
Page: https://arcprompts.lovable.app/ideas/fashion-fabricbatch-chain-14

Build "FabricBatch Chain" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Log fabric batch quality certifications on-chain for designer trust and compliance.
Discipline: Fashion & Textile Design (batch quality control). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a batch quality control item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The batch quality control flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA fashion-wearablestats-token-15 · Base · WearableStats Token =====
Page: https://arcprompts.lovable.app/ideas/fashion-wearablestats-token-15

Build "WearableStats Token" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Tokenize data from smart textiles to reward sustainable usage behaviors.
Discipline: Fashion & Textile Design (performance textiles). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a performance textiles item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The performance textiles flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA fashion-virtualrunway-dao-16 · Base · VirtualRunway DAO =====
Page: https://arcprompts.lovable.app/ideas/fashion-virtualrunway-dao-16

Build "VirtualRunway DAO" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Host decentralized, verifiable virtual fashion events with transparent gatekeeping.
Discipline: Fashion & Textile Design (digital fashion shows). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a digital fashion shows item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The digital fashion shows flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA fashion-textilewaste-nft-17 · Base · TextileWaste NFT =====
Page: https://arcprompts.lovable.app/ideas/fashion-textilewaste-nft-17

Build "TextileWaste NFT" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Issue NFTs certifying textile waste recycling to promote circular fashion.
Discipline: Fashion & Textile Design (waste management). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a waste management item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The waste management flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA fashion-patternproof-chain-18 · Base · PatternProof Chain =====
Page: https://arcprompts.lovable.app/ideas/fashion-patternproof-chain-18

Build "PatternProof Chain" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Verify pattern originality and ownership in decentralized on-chain records.
Discipline: Fashion & Textile Design (pattern authenticity). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a pattern authenticity item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The pattern authenticity flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA fashion-accessoryauth-mint-19 · Base · AccessoryAuth Mint =====
Page: https://arcprompts.lovable.app/ideas/fashion-accessoryauth-mint-19

Build "AccessoryAuth Mint" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Issue NFTs authenticating limited-edition fashion accessories to combat counterfeits.
Discipline: Fashion & Textile Design (accessory authentication). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a accessory authentication item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The accessory authentication flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA fashion-fashioncontractor-dao-20 · Base · FashionContractor DAO =====
Page: https://arcprompts.lovable.app/ideas/fashion-fashioncontractor-dao-20

Build "FashionContractor DAO" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Manage freelance fashion contracts transparently with on-chain escrow and milestones.
Discipline: Fashion & Textile Design (freelance contract management). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a freelance contract management item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The freelance contract management flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA fashion-digitalswatch-token-21 · Base · DigitalSwatch Token =====
Page: https://arcprompts.lovable.app/ideas/fashion-digitalswatch-token-21

Build "DigitalSwatch Token" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Create and trade verified digital fabric swatches with immutable ownership records.
Discipline: Fashion & Textile Design (digital fabric samples). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a digital fabric samples item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The digital fabric samples flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA fashion-ecofashion-dao-22 · Base · EcoFashion DAO =====
Page: https://arcprompts.lovable.app/ideas/fashion-ecofashion-dao-22

Build "EcoFashion DAO" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Govern eco-friendly fashion initiatives via decentralized, transparent smart contracts.
Discipline: Fashion & Textile Design (sustainability governance). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a sustainability governance item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The sustainability governance flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA fashion-runwayroyalties-nft-23 · Base · RunwayRoyalties NFT =====
Page: https://arcprompts.lovable.app/ideas/fashion-runwayroyalties-nft-23

Build "RunwayRoyalties NFT" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Automate royalty distribution for runway show participants through NFT smart contracts.
Discipline: Fashion & Textile Design (event royalty management). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a event royalty management item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The event royalty management flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA fashion-styleswap-chain-24 · Base · StyleSwap Chain =====
Page: https://arcprompts.lovable.app/ideas/fashion-styleswap-chain-24

Build "StyleSwap Chain" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Trade digital fashion items securely with on-chain ownership and transfer records.
Discipline: Fashion & Textile Design (digital fashion exchange). Primitive: OUSD payments — A one-tap OUSD transfer from the user's Privy wallet to the creator, confirmed on chain.

USER FLOW
The user picks a digital fashion exchange item priced in OUSD (default 1.00 OUSD), taps Pay, confirms once in Privy, and sees a receipt with amount, time and the explorer link.
UI: A price tag in OUSD, a single Pay button, and a receipt with the explorer link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The digital fashion exchange flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA fashion-fabric-storyline-0 · Base · Fabric Storyline =====
Page: https://arcprompts.lovable.app/ideas/fashion-fabric-storyline-0

Build "Fabric Storyline" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Securely archive and share original fabric patterns with permanent proof of creativity.
Discipline: Fashion & Textile Design (digital textile archives). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a digital textile archives sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The digital textile archives flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA fashion-runway-replay-1 · Base · Runway Replay =====
Page: https://arcprompts.lovable.app/ideas/fashion-runway-replay-1

Build "Runway Replay" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin high-resolution show images and metadata to create an unalterable runway history.
Discipline: Fashion & Textile Design (fashion show documentation). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a fashion show documentation sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The fashion show documentation flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA fashion-color-code-vault-2 · Base · Color Code Vault =====
Page: https://arcprompts.lovable.app/ideas/fashion-color-code-vault-2

Build "Color Code Vault" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Store confirmed color palettes and their usage securely for design authenticity.
Discipline: Fashion & Textile Design (color palette preservation). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a color palette preservation sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The color palette preservation flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA fashion-stitch-trace-3 · Base · Stitch Trace =====
Page: https://arcprompts.lovable.app/ideas/fashion-stitch-trace-3

Build "Stitch Trace" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Record detailed stitch patterns and techniques on-chain to prove craftsmanship.
Discipline: Fashion & Textile Design (garment construction logs). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a garment construction logs sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The garment construction logs flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA fashion-moodboard-ledger-4 · Base · Moodboard Ledger =====
Page: https://arcprompts.lovable.app/ideas/fashion-moodboard-ledger-4

Build "Moodboard Ledger" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin moodboards with images and notes securely to track creative evolution.
Discipline: Fashion & Textile Design (inspiration curation). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a inspiration curation sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The inspiration curation flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA fashion-trend-lineage-5 · Base · Trend Lineage =====
Page: https://arcprompts.lovable.app/ideas/fashion-trend-lineage-5

Build "Trend Lineage" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Archive trend data and visuals to verify origin and evolution of styles.
Discipline: Fashion & Textile Design (fashion trend mapping). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a fashion trend mapping sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The fashion trend mapping flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA fashion-texture-token-6 · Base · Texture Token =====
Page: https://arcprompts.lovable.app/ideas/fashion-texture-token-6

Build "Texture Token" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin high-res texture samples for sharing and verifying textile uniqueness.
Discipline: Fashion & Textile Design (fabric texture archives). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a fabric texture archives sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The fabric texture archives flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA fashion-fit-file-safe-7 · Base · Fit File Safe =====
Page: https://arcprompts.lovable.app/ideas/fashion-fit-file-safe-7

Build "Fit File Safe" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Store 3D fitting session data securely for consistent tailoring and reuse.
Discipline: Fashion & Textile Design (3D garment fitting). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a 3D garment fitting sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The 3D garment fitting flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA fashion-accessory-archive-8 · Base · Accessory Archive =====
Page: https://arcprompts.lovable.app/ideas/fashion-accessory-archive-8

Build "Accessory Archive" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin detailed accessory designs for easy access and IP validation.
Discipline: Fashion & Textile Design (digital accessory cataloging). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a digital accessory cataloging sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The digital accessory cataloging flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA fashion-capsule-catalog-9 · Base · Capsule Catalog =====
Page: https://arcprompts.lovable.app/ideas/fashion-capsule-catalog-9

Build "Capsule Catalog" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Store entire seasonal lookbooks as immutable IPFS manifests for authenticity.
Discipline: Fashion & Textile Design (seasonal collection storage). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a seasonal collection storage sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The seasonal collection storage flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA fashion-drape-documentation-10 · Base · Drape Documentation =====
Page: https://arcprompts.lovable.app/ideas/fashion-drape-documentation-10

Build "Drape Documentation" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin high-res photos and notes on draping experiments for design validation.
Discipline: Fashion & Textile Design (fabric draping records). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a fabric draping records sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The fabric draping records flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA fashion-print-provenance-11 · Base · Print Provenance =====
Page: https://arcprompts.lovable.app/ideas/fashion-print-provenance-11

Build "Print Provenance" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Securely pin original print artworks to prevent unauthorized reproduction.
Discipline: Fashion & Textile Design (digital print design). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a digital print design sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The digital print design flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA fashion-ecofabric-ledger-12 · Base · EcoFabric Ledger =====
Page: https://arcprompts.lovable.app/ideas/fashion-ecofabric-ledger-12

Build "EcoFabric Ledger" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Archive sustainability data and certifications for eco-friendly fabrics.
Discipline: Fashion & Textile Design (sustainable textile tracking). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a sustainable textile tracking sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The sustainable textile tracking flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA fashion-pattern-pathway-13 · Base · Pattern Pathway =====
Page: https://arcprompts.lovable.app/ideas/fashion-pattern-pathway-13

Build "Pattern Pathway" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin editable pattern files for seamless transfer and secure versioning.
Discipline: Fashion & Textile Design (seamless pattern sharing). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a seamless pattern sharing sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The seamless pattern sharing flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA fashion-avant-atlas-14 · Base · Avant Atlas =====
Page: https://arcprompts.lovable.app/ideas/fashion-avant-atlas-14

Build "Avant Atlas" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Store experimental fashion concepts securely to document avant-garde evolution.
Discipline: Fashion & Textile Design (experimental design archives). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a experimental design archives sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The experimental design archives flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA fashion-fabric-fusion-15 · Base · Fabric Fusion =====
Page: https://arcprompts.lovable.app/ideas/fashion-fabric-fusion-15

Build "Fabric Fusion" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin multimedia fabric experiments combining textiles and digital art.
Discipline: Fashion & Textile Design (mixed media textile records). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a mixed media textile records sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The mixed media textile records flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA fashion-wearable-wallet-16 · Base · Wearable Wallet =====
Page: https://arcprompts.lovable.app/ideas/fashion-wearable-wallet-16

Build "Wearable Wallet" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin detailed digital wardrobe inventories with immutable metadata.
Discipline: Fashion & Textile Design (digital wardrobe management). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a digital wardrobe management sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The digital wardrobe management flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA fashion-costume-chronicle-17 · Base · Costume Chronicle =====
Page: https://arcprompts.lovable.app/ideas/fashion-costume-chronicle-17

Build "Costume Chronicle" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Securely archive costume design images and details for production history.
Discipline: Fashion & Textile Design (theatrical costume records). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a theatrical costume records sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The theatrical costume records flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA fashion-style-snapshot-18 · Base · Style Snapshot =====
Page: https://arcprompts.lovable.app/ideas/fashion-style-snapshot-18

Build "Style Snapshot" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin curated influencer style images and metadata for trend analysis.
Discipline: Fashion & Textile Design (fashion influencer galleries). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a fashion influencer galleries sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The fashion influencer galleries flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA fashion-thread-token-19 · Base · Thread Token =====
Page: https://arcprompts.lovable.app/ideas/fashion-thread-token-19

Build "Thread Token" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin yarn samples and thread color specs for easy supplier access.
Discipline: Fashion & Textile Design (yarn and thread digital catalogs). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a yarn and thread digital catalogs sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The yarn and thread digital catalogs flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA fashion-fashion-footprint-20 · Base · Fashion Footprint =====
Page: https://arcprompts.lovable.app/ideas/fashion-fashion-footprint-20

Build "Fashion Footprint" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin comprehensive lifecycle data of designs for transparency and accountability.
Discipline: Fashion & Textile Design (design lifecycle tracking). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a design lifecycle tracking sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The design lifecycle tracking flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA fashion-pattern-nft-forge-21 · Base · Pattern NFT Forge =====
Page: https://arcprompts.lovable.app/ideas/fashion-pattern-nft-forge-21

Build "Pattern NFT Forge" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin pattern files to IPFS to mint unique, verifiable design NFTs.
Discipline: Fashion & Textile Design (blockchain pattern minting). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a blockchain pattern minting sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The blockchain pattern minting flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA fashion-digital-drapery-hub-22 · Base · Digital Drapery Hub =====
Page: https://arcprompts.lovable.app/ideas/fashion-digital-drapery-hub-22

Build "Digital Drapery Hub" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin fabric simulation data and images for shared digital draping experiences.
Discipline: Fashion & Textile Design (online fabric simulation). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a online fabric simulation sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The online fabric simulation flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA fashion-ethical-edit-log-23 · Base · Ethical Edit Log =====
Page: https://arcprompts.lovable.app/ideas/fashion-ethical-edit-log-23

Build "Ethical Edit Log" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin timestamps and notes on ethical design choices for industry trust.
Discipline: Fashion & Textile Design (design decision auditing). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a design decision auditing sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The design decision auditing flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA fashion-silhouette-sync-24 · Base · Silhouette Sync =====
Page: https://arcprompts.lovable.app/ideas/fashion-silhouette-sync-24

Build "Silhouette Sync" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Pin silhouette sketches and metadata for collaborative design iterations.
Discipline: Fashion & Textile Design (design silhouette sharing). Primitive: OUSD payouts & splits — One payment is split into several OUSD transfers to collaborators by fixed percentages.

USER FLOW
A creator defines a split (e.g. 70/20/10) for a design silhouette sharing sale. A buyer pays once; the app sends the OUSD shares sequentially from the buyer's wallet and lists each transfer with its explorer link.
UI: A split editor (names + %) and a payout ledger with one explorer link per transfer.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The design silhouette sharing flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA fashion-fabric-storychain-0 · Base · Fabric Storychain =====
Page: https://arcprompts.lovable.app/ideas/fashion-fabric-storychain-0

Build "Fabric Storychain" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Track textile origins transparently for designers and consumers to verify authenticity.
Discipline: Fashion & Textile Design (material provenance). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a material provenance action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The material provenance flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA fashion-moodboard-mint-1 · Base · Moodboard Mint =====
Page: https://arcprompts.lovable.app/ideas/fashion-moodboard-mint-1

Build "Moodboard Mint" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Create and share moodboards that capture design inspirations with onchain credits and permissions.
Discipline: Fashion & Textile Design (collaborative curation). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a collaborative curation action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The collaborative curation flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA fashion-trendtoken-vault-2 · Base · TrendToken Vault =====
Page: https://arcprompts.lovable.app/ideas/fashion-trendtoken-vault-2

Build "TrendToken Vault" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Collect and verify emerging fashion trends via community consensus and rewarded participation.
Discipline: Fashion & Textile Design (trend validation). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a trend validation action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The trend validation flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA fashion-patternshare-3 · Base · PatternShare =====
Page: https://arcprompts.lovable.app/ideas/fashion-patternshare-3

Build "PatternShare" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Securely share and license digital sewing patterns with transparent ownership and usage rights.
Discipline: Fashion & Textile Design (digital pattern exchange). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a digital pattern exchange action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The digital pattern exchange flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA fashion-colorchain-palette-4 · Base · ColorChain Palette =====
Page: https://arcprompts.lovable.app/ideas/fashion-colorchain-palette-4

Build "ColorChain Palette" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Verify and share color formula origins to protect designer intellectual property.
Discipline: Fashion & Textile Design (color provenance). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a color provenance action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The color provenance flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA fashion-wearable-royalties-5 · Base · Wearable Royalties =====
Page: https://arcprompts.lovable.app/ideas/fashion-wearable-royalties-5

Build "Wearable Royalties" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Automatically distribute royalties for digital fashion assets across creators and brands.
Discipline: Fashion & Textile Design (digital fashion royalties). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a digital fashion royalties action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The digital fashion royalties flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA fashion-runway-replay-6 · Base · Runway Replay =====
Page: https://arcprompts.lovable.app/ideas/fashion-runway-replay-6

Build "Runway Replay" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Capture and timestamp runway shows for authenticity and replay rights management.
Discipline: Fashion & Textile Design (event recording). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a event recording action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The event recording flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA fashion-sartorial-social-7 · Base · Sartorial Social =====
Page: https://arcprompts.lovable.app/ideas/fashion-sartorial-social-7

Build "Sartorial Social" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Connect fashion creatives with gasless transactions enabling easy contract signing and collaborations.
Discipline: Fashion & Textile Design (designer networking). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a designer networking action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The designer networking flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA fashion-fabric-fraction-8 · Base · Fabric Fraction =====
Page: https://arcprompts.lovable.app/ideas/fashion-fabric-fraction-8

Build "Fabric Fraction" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Enable fractional ownership of rare textile swatches through secure tokenization and seamless onboarding.
Discipline: Fashion & Textile Design (material micro-ownership). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a material micro-ownership action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The material micro-ownership flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA fashion-virtual-trychain-9 · Base · Virtual Trychain =====
Page: https://arcprompts.lovable.app/ideas/fashion-virtual-trychain-9

Build "Virtual Trychain" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Authenticate virtual try-on sessions and purchases transparently for customers and brands.
Discipline: Fashion & Textile Design (try-on verification). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a try-on verification action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The try-on verification flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA fashion-capsule-contract-11 · Base · Capsule Contract =====
Page: https://arcprompts.lovable.app/ideas/fashion-capsule-contract-11

Build "Capsule Contract" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Enable designers to co-create and manage capsule collections with frictionless onchain agreements.
Discipline: Fashion & Textile Design (collaborative capsule collections). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a collaborative capsule collections action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The collaborative capsule collections flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA fashion-style-stake-12 · Base · Style Stake =====
Page: https://arcprompts.lovable.app/ideas/fashion-style-stake-12

Build "Style Stake" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Stake tokens to support favorite designers and earn rewards through community votes.
Discipline: Fashion & Textile Design (community style curation). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a community style curation action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The community style curation flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA fashion-fabric-swapchain-13 · Base · Fabric Swapchain =====
Page: https://arcprompts.lovable.app/ideas/fashion-fabric-swapchain-13

Build "Fabric Swapchain" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Decentralize textile swaps between designers via secure tokenized exchanges.
Discipline: Fashion & Textile Design (material bartering). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a material bartering action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The material bartering flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA fashion-runway-reward-14 · Base · Runway Reward =====
Page: https://arcprompts.lovable.app/ideas/fashion-runway-reward-14

Build "Runway Reward" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Reward attendance and participation at fashion events with tokenized perks and proof of presence.
Discipline: Fashion & Textile Design (event incentives). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a event incentives action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The event incentives flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA fashion-style-snapshot-15 · Base · Style Snapshot =====
Page: https://arcprompts.lovable.app/ideas/fashion-style-snapshot-15

Build "Style Snapshot" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Securely log daily outfits as NFTs with easy social sign-in and no gas cost.
Discipline: Fashion & Textile Design (digital outfit logging). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a digital outfit logging action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The digital outfit logging flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA fashion-craft-credit-16 · Base · Craft Credit =====
Page: https://arcprompts.lovable.app/ideas/fashion-craft-credit-16

Build "Craft Credit" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Automatically credit textile artisans in design chains with transparent onchain records.
Discipline: Fashion & Textile Design (artisan attribution). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a artisan attribution action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The artisan attribution flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA fashion-pattern-provenance-17 · Base · Pattern Provenance =====
Page: https://arcprompts.lovable.app/ideas/fashion-pattern-provenance-17

Build "Pattern Provenance" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Protect sewing patterns with immutable copyright records accessible via Google login.
Discipline: Fashion & Textile Design (design copyright). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a design copyright action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The design copyright flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA fashion-tailor-token-18 · Base · Tailor Token =====
Page: https://arcprompts.lovable.app/ideas/fashion-tailor-token-18

Build "Tailor Token" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Enable tailors to accept and manage custom orders via tokenized contracts and gasless sign-in.
Discipline: Fashion & Textile Design (custom order management). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a custom order management action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The custom order management flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA fashion-fashion-dao-hub-19 · Base · Fashion DAO Hub =====
Page: https://arcprompts.lovable.app/ideas/fashion-fashion-dao-hub-19

Build "Fashion DAO Hub" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Empower designer collectives to govern projects through token voting with easy wallet setup.
Discipline: Fashion & Textile Design (decentralized fashion governance). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a decentralized fashion governance action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The decentralized fashion governance flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA fashion-vintage-vault-20 · Base · Vintage Vault =====
Page: https://arcprompts.lovable.app/ideas/fashion-vintage-vault-20

Build "Vintage Vault" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Authenticate vintage fashion pieces via onchain certificates linked to verified user profiles.
Discipline: Fashion & Textile Design (authenticity verification). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a authenticity verification action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The authenticity verification flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA fashion-style-swap-21 · Base · Style Swap =====
Page: https://arcprompts.lovable.app/ideas/fashion-style-swap-21

Build "Style Swap" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Facilitate safe swaps of clothing items with secure tokenized agreements and zero gas fees.
Discipline: Fashion & Textile Design (peer-to-peer fashion exchange). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a peer-to-peer fashion exchange action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The peer-to-peer fashion exchange flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA fashion-textile-tokenizer-22 · Base · Textile Tokenizer =====
Page: https://arcprompts.lovable.app/ideas/fashion-textile-tokenizer-22

Build "Textile Tokenizer" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Convert physical textile assets into digital tokens for trading and provenance tracking.
Discipline: Fashion & Textile Design (fabric asset digitization). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a fabric asset digitization action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The fabric asset digitization flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA fashion-designer-direct-23 · Base · Designer Direct =====
Page: https://arcprompts.lovable.app/ideas/fashion-designer-direct-23

Build "Designer Direct" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Connect designers directly with suppliers using onchain verified transactions and profiles.
Discipline: Fashion & Textile Design (supply chain transparency). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a supply chain transparency action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The supply chain transparency flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA fashion-capsule-claim-24 · Base · Capsule Claim =====
Page: https://arcprompts.lovable.app/ideas/fashion-capsule-claim-24

Build "Capsule Claim" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Issue onchain certificates for limited edition capsule collections ensuring buyer confidence.
Discipline: Fashion & Textile Design (limited drop authentication). Primitive: Privy social wallet — Google sign-in creates an embedded wallet on the chosen chain; the user sees an OUSD balance, not crypto jargon.

USER FLOW
The user signs in with Google, gets an embedded wallet, sees their OUSD balance, and performs a limited drop authentication action that sends a small OUSD tip (0.10 OUSD) to the creator, with an explorer link.
UI: Sign-in button, balance card in OUSD, and a receive address with copy + QR.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The limited drop authentication flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA fashion-thread-legacy-0 · Base · Thread Legacy =====
Page: https://arcprompts.lovable.app/ideas/fashion-thread-legacy-0

Build "Thread Legacy" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Authenticate fabric origins transparently for sustainable fashion designers.
Discipline: Fashion & Textile Design (fabric provenance). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a fabric provenance work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The fabric provenance flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA fashion-costume-chronicle-1 · Base · Costume Chronicle =====
Page: https://arcprompts.lovable.app/ideas/fashion-costume-chronicle-1

Build "Costume Chronicle" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Securely mint and showcase original costume designs as unique digital collectibles.
Discipline: Fashion & Textile Design (historical costume design). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a historical costume design work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The historical costume design flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA fashion-style-vault-2 · Base · Style Vault =====
Page: https://arcprompts.lovable.app/ideas/fashion-style-vault-2

Build "Style Vault" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Create exclusive NFT collections of curated outfits for personalized style portfolios.
Discipline: Fashion & Textile Design (outfit curation). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a outfit curation work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The outfit curation flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA fashion-pattern-provenance-3 · Base · Pattern Provenance =====
Page: https://arcprompts.lovable.app/ideas/fashion-pattern-provenance-3

Build "Pattern Provenance" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Record and verify original textile patterns as immutable digital assets.
Discipline: Fashion & Textile Design (textile pattern design). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a textile pattern design work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The textile pattern design flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA fashion-colorcode-ledger-4 · Base · ColorCode Ledger =====
Page: https://arcprompts.lovable.app/ideas/fashion-colorcode-ledger-4

Build "ColorCode Ledger" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Authenticate unique color palettes as exclusive NFTs for designers' intellectual property.
Discipline: Fashion & Textile Design (color study). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a color study work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The color study flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA fashion-fabric-nft-atlas-5 · Base · Fabric NFT Atlas =====
Page: https://arcprompts.lovable.app/ideas/fashion-fabric-nft-atlas-5

Build "Fabric NFT Atlas" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Map and mint provenance NFTs for regional and artisanal fabric producers.
Discipline: Fashion & Textile Design (textile sourcing). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a textile sourcing work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The textile sourcing flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA fashion-design-chain-diary-6 · Base · Design Chain Diary =====
Page: https://arcprompts.lovable.app/ideas/fashion-design-chain-diary-6

Build "Design Chain Diary" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Chronologically mint fashion sketches as NFTs to prove creative progress and ownership.
Discipline: Fashion & Textile Design (fashion sketching). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a fashion sketching work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The fashion sketching flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA fashion-capsule-mint-7 · Base · Capsule Mint =====
Page: https://arcprompts.lovable.app/ideas/fashion-capsule-mint-7

Build "Capsule Mint" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Issue limited-edition fashion collection NFTs with provenance for pre-sale exclusivity.
Discipline: Fashion & Textile Design (collection drops). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a collection drops work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The collection drops flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA fashion-weave-witness-8 · Base · Weave Witness =====
Page: https://arcprompts.lovable.app/ideas/fashion-weave-witness-8

Build "Weave Witness" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint NFTs to certify handcrafted fabric authenticity and artisan identity.
Discipline: Fashion & Textile Design (handloom textiles). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a handloom textiles work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The handloom textiles flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA fashion-trend-tokenizer-9 · Base · Trend Tokenizer =====
Page: https://arcprompts.lovable.app/ideas/fashion-trend-tokenizer-9

Build "Trend Tokenizer" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint data-driven trend insights as NFTs to securely sell forecasting reports.
Discipline: Fashion & Textile Design (fashion forecasting). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a fashion forecasting work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The fashion forecasting flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA fashion-fashion-dna-10 · Base · Fashion DNA =====
Page: https://arcprompts.lovable.app/ideas/fashion-fashion-dna-10

Build "Fashion DNA" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Create unique NFTs representing brand values and design DNA to protect brand authenticity.
Discipline: Fashion & Textile Design (brand identity). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a brand identity work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The brand identity flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA fashion-upcycle-proof-11 · Base · Upcycle Proof =====
Page: https://arcprompts.lovable.app/ideas/fashion-upcycle-proof-11

Build "Upcycle Proof" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint NFTs for upcycled garment transformations as proof of sustainable creative ownership.
Discipline: Fashion & Textile Design (sustainable design). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a sustainable design work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The sustainable design flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA fashion-moodboard-mint-13 · Base · Moodboard Mint =====
Page: https://arcprompts.lovable.app/ideas/fashion-moodboard-mint-13

Build "Moodboard Mint" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Securely mint fashion moodboards as NFTs to claim original inspiration and concepts.
Discipline: Fashion & Textile Design (concept curation). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a concept curation work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The concept curation flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA fashion-fit-nft-lab-14 · Base · Fit NFT Lab =====
Page: https://arcprompts.lovable.app/ideas/fashion-fit-nft-lab-14

Build "Fit NFT Lab" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint verified NFTs representing customizable fit parameters for digital wardrobe pieces.
Discipline: Fashion & Textile Design (virtual fitting). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a virtual fitting work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The virtual fitting flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA fashion-runway-record-15 · Base · Runway Record =====
Page: https://arcprompts.lovable.app/ideas/fashion-runway-record-15

Build "Runway Record" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint NFTs documenting runway shows’ looks for authentic digital archiving and resale.
Discipline: Fashion & Textile Design (showcase curation). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a showcase curation work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The showcase curation flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA fashion-fabric-remix-16 · Base · Fabric Remix =====
Page: https://arcprompts.lovable.app/ideas/fashion-fabric-remix-16

Build "Fabric Remix" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint NFTs for remixed fabric patterns proving originality and creative lineage.
Discipline: Fashion & Textile Design (textile remixing). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a textile remixing work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The textile remixing flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA fashion-sustainable-stitch-17 · Base · Sustainable Stitch =====
Page: https://arcprompts.lovable.app/ideas/fashion-sustainable-stitch-17

Build "Sustainable Stitch" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint NFTs proving zero-waste garment designs for fashion sustainability verification.
Discipline: Fashion & Textile Design (zero-waste design). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a zero-waste design work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The zero-waste design flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA fashion-digital-drapes-18 · Base · Digital Drapes =====
Page: https://arcprompts.lovable.app/ideas/fashion-digital-drapes-18

Build "Digital Drapes" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Create NFTs certifying original digital drape and garment simulations for designers.
Discipline: Fashion & Textile Design (3D garment design). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a 3D garment design work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The 3D garment design flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA fashion-ethnic-essence-19 · Base · Ethnic Essence =====
Page: https://arcprompts.lovable.app/ideas/fashion-ethnic-essence-19

Build "Ethnic Essence" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint NFTs to protect and showcase indigenous and ethnic textile designs.
Discipline: Fashion & Textile Design (cultural textiles). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a cultural textiles work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The cultural textiles flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA fashion-accessory-authenticator-20 · Base · Accessory Authenticator =====
Page: https://arcprompts.lovable.app/ideas/fashion-accessory-authenticator-20

Build "Accessory Authenticator" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint unique NFTs proving authenticity and limited runs of accessory designs.
Discipline: Fashion & Textile Design (limited-edition accessories). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a limited-edition accessories work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The limited-edition accessories flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA fashion-craft-chain-connect-21 · Base · Craft Chain Connect =====
Page: https://arcprompts.lovable.app/ideas/fashion-craft-chain-connect-21

Build "Craft Chain Connect" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint collaborative NFTs documenting co-creation between designers and artisans.
Discipline: Fashion & Textile Design (artisan collaboration). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a artisan collaboration work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The artisan collaboration flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA fashion-virtual-vogue-vault-22 · Base · Virtual Vogue Vault =====
Page: https://arcprompts.lovable.app/ideas/fashion-virtual-vogue-vault-22

Build "Virtual Vogue Vault" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint NFT archives of vintage and digital fashion pieces for authenticated preservation.
Discipline: Fashion & Textile Design (digital fashion archives). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a digital fashion archives work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The digital fashion archives flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA fashion-print-proofs-23 · Base · Print Proofs =====
Page: https://arcprompts.lovable.app/ideas/fashion-print-proofs-23

Build "Print Proofs" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint NFTs to prove original fabric print designs’ authorship and exclusivity.
Discipline: Fashion & Textile Design (fabric print designs). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a fabric print designs work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The fabric print designs flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".

===== IDEA fashion-style-storyline-24 · Base · Style Storyline =====
Page: https://arcprompts.lovable.app/ideas/fashion-style-storyline-24

Build "Style Storyline" in ONE Lovable message. A single-page app that uses OUSD (Open USD) on mainnet.

CONCEPT
Mint NFTs encoding fashion collection narratives as immutable digital assets.
Discipline: Fashion & Textile Design (fashion storytelling). Primitive: OUSD-priced provenance — Buying or licensing a work is an OUSD transfer; the tx hash becomes the provenance record.

USER FLOW
The user licenses a fashion storytelling work for an OUSD price. The tx hash, buyer, price and timestamp are saved and rendered as a shareable certificate that links to the explorer.
UI: A certificate card showing buyer, price in OUSD, time and the explorer proof link.

CHAIN — Base MAINNET (real money, no testnet)
- chainId 8453 · RPC https://mainnet.base.org · Explorer https://basescan.org
- OUSD on Base: 0xB2000000000000000000002fEb517dFeC7415344
- Tx link: https://basescan.org/tx/<hash> · Contract page: https://basescan.org/address/0xB2000000000000000000002fEb517dFeC7415344
- Gas: ETH on Base (cheap). Turn on Privy gas sponsorship for Base so users never need ETH.
- viem: `import { base } from 'viem/chains'` — use it as Privy `defaultChain` and in `supportedChains`.
- OUSD is an ERC-20. Transfer with `encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, amount] })`, `value: 0n`, sent TO the OUSD address.
- Read `decimals()` from the contract once at boot — never hardcode it.
- Pass `{ sponsor: true }` to Privy `sendTransaction` (needs Base enabled in Privy → Gas Sponsorship).

CODE — paste these files as-is (install: `@privy-io/react-auth viem`)

// src/lib/ousd.ts
import { base as CHAIN } from 'viem/chains';
export { CHAIN };
import { createPublicClient, http, erc20Abi, encodeFunctionData, parseUnits, formatUnits } from 'viem';
export const OUSD = '0xB2000000000000000000002fEb517dFeC7415344' as const;
export const pub = createPublicClient({ chain: CHAIN, transport: http('https://mainnet.base.org') });
let dec: number | undefined;
export async function ousdDecimals() { return dec ??= await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'decimals' }); }
export async function ousdBalance(owner: `0x${string}`) {
  const raw = await pub.readContract({ address: OUSD, abi: erc20Abi, functionName: 'balanceOf', args: [owner] });
  return Number(formatUnits(raw, await ousdDecimals()));
}
export async function transferTx(to: `0x${string}`, amount: string) {
  const value = parseUnits(amount, await ousdDecimals());
  return { to: OUSD, value: 0n, chainId: CHAIN.id,
    data: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [to, value] }) };
}
export const txUrl = (h: string) => 'https://basescan.org/tx/' + h;
export async function waitFor(hash: `0x${string}`) { return pub.waitForTransactionReceipt({ hash, timeout: 90_000 }); }

// src/components/privy-root.tsx  (default export; loaded with React.lazy inside <ClientOnly>)
import { PrivyProvider } from '@privy-io/react-auth';
import { CHAIN } from '@/lib/ousd';
export default function PrivyRoot({ appId, children }: { appId: string; children: React.ReactNode }) {
  return <PrivyProvider appId={appId} config={{ loginMethods: ['google'], defaultChain: CHAIN, supportedChains: [CHAIN],
    embeddedWallets: { ethereum: { createOnLogin: 'users-without-wallets' } } }}>{children}</PrivyProvider>;
}

// Sending (inside a component under PrivyRoot)
// const { sendTransaction } = useSendTransaction();       // from '@privy-io/react-auth'
// const { hash } = await sendTransaction(await transferTx(to, '1.00'), { sponsor: true });
// await waitFor(hash); show txUrl(hash).

STACK
- TanStack Start (the Lovable default). One page at the index route.
- Privy for sign-in (Google) and embedded wallets on the chain below. Load Privy with
  `React.lazy(() => import('./privy-root'))` inside `<ClientOnly>` — a static import crashes SSR.
- Secret `PRIVY_APP_ID` (paste in Project Settings → Secrets). Read it in a route loader via a server
  function (`process.env.PRIVY_APP_ID`) and pass it to the provider. NEVER name a secret `VITE_*`.
- Show amounts in OUSD with 2 decimals; convert with the on-chain decimals.
- No smart contract deploy is needed: OUSD is already live. Every action is an OUSD token transfer.

SHARED CODE — paste as-is
// src/lib/privy.functions.ts
import { createServerFn } from '@tanstack/react-start';
export const getPrivyAppId = createServerFn({ method: 'GET' })
  .handler(async () => ({ appId: process.env['PRIVY_APP_ID'] ?? null }));

// src/routes/index.tsx (shape)
// loader: () => getPrivyAppId()
// const { appId } = Route.useLoaderData();
// const PrivyRoot = React.lazy(() => import('@/components/privy-root'));
// if (!appId) render the full UI in demo mode with a banner "Add PRIVY_APP_ID to go live" (no sends).
// else: <ClientOnly fallback={<Skeleton/>}><Suspense><PrivyRoot appId={appId}><App/></PrivyRoot></Suspense></ClientOnly>
// Inside <App/>: const { ready, authenticated, login, logout } = usePrivy(); wait for `ready` before reading wallets.

REAL MONEY RULES (mainnet only)
- Above every Pay button show: "Mainnet · real OUSD". Default demo amounts ≤ 1 OUSD.
- Before sending, check the OUSD balance; if too low, show "Get OUSD" linking to https://joinopenstandard.com/integrate.
- Always confirm the wallet is on the right chain before sending; refuse with a clear "switch network" message otherwise.
- After sending, wait for confirmation, then show the explorer link. Never show success before confirmation.

TROUBLESHOOTING
- "window is not defined" / blank SSR page → Privy was imported statically. Only import it via React.lazy inside <ClientOnly>.
- Wrong network / chain mismatch → defaultChain and supportedChains must be the same chain object; refuse to send otherwise.
- Solana "TokenAccountNotFound" → the idempotent create-ATA instruction must precede the transfer; balance = 0 when no ATA.
- "insufficient funds for gas" → enable Privy gas sponsorship for this chain, or tell the user which gas coin to add.
- Balance too low → disable Pay and show "Get OUSD" linking to https://joinopenstandard.com/integrate.

COMPLIANCE (mandatory — OUSD is issued by Bridge, a Stripe company)
- Show a footer notice: "OUSD is not available in the European Economic Area or sanctioned regions. See https://joinopenstandard.com/legal/geo-restrictions-and-prohibited-use-cases".
- Never build or market for prohibited uses: gambling, games of chance, lotteries, sweepstakes, unlawful
  prediction markets, adult content, cannabis, tobacco, weapons, pharmaceuticals, luxury goods, jewelry,
  watches, precious metals, mixing, multi-level marketing, counterfeit goods or deceptive practices.
- OUSD is acquired through partners (Stripe/Bridge/Privy, Coinbase, Visa, Mastercard) or exchanges
  (Coinbase, Kraken, Uniswap). The app itself never mints or redeems.

DEFINITION OF DONE
1. Google sign-in via Privy creates an embedded wallet on the chain above and shows its OUSD balance.
2. The fashion storytelling flow sends a real OUSD transfer, waits for confirmation, and shows a working explorer link.
3. The compliance footer and the real-money notice are visible.
4. The page works with zero secrets (demo mode with a "Add PRIVY_APP_ID to go live" banner).

Credit in the footer: "Built during the Creative AI & Quantum Hackathon organised by StreetKode Fam during Indian Krump Festival 14".