plotlink-ows 1.2.97 → 1.2.99

package/README.md

@@ -271,6 +271,23 @@ npm run app:start    # Serve production build
 
 See [`.env.example`](.env.example) for configuration options.
 
+### Release Checklist
+
+For manual npm releases, always update GitHub Releases as part of publish
+preparation. The release tag must match the npm version (`vX.Y.Z`), and the
+release page should be created or updated before running `npm publish`.
+
+```bash
+npm run preflight
+git push origin main --follow-tags
+gh release create "v$(node -p 'require("./package.json").version')" --generate-notes --latest
+npm publish
+```
+
+Prefer `npm run release:patch`, `npm run release:minor`, or
+`npm run release:major` when the version bump is straightforward; those scripts
+already include GitHub Release creation.
+
 ---
 
 ## 🔗 Links

package/app/routes/dashboard.ts

@@ -1,9 +1,9 @@
 import { Hono } from "hono";
-import { createPublicClient, http } from "viem";
+import { createPublicClient, createWalletClient, formatUnits, http, type Address } from "viem";
 import { base } from "viem/chains";
 import fs from "fs";
 import path from "path";
-import { getEthBalance } from "../lib/publish";
+import { createOwsAccount, getEthBalance } from "../lib/publish";
 import { resolveActiveWallet } from "../lib/active-wallet";
 import { mcv2BondAbi } from "../../packages/cli/src/sdk/abi";
 import { STORIES_DIR, readPublishStatus } from "./stories";
@@ -19,6 +19,10 @@ const publicClient = createPublicClient({
 
 const dashboard = new Hono();
 
+function formatPlot(value: bigint): string {
+  return Number(formatUnits(value, 18)).toFixed(6);
+}
+
 /** GET /api/dashboard — writer dashboard data */
 dashboard.get("/", async (c) => {
   // Scan stories/ for publish status
@@ -125,9 +129,10 @@ dashboard.get("/", async (c) => {
   }, BigInt(0));
   const totalGasCostEth = (Number(totalGasCostWei) / 1e18).toFixed(6);
 
-  // Query on-chain royalties (WETH on Base — bonding curve reserve)
+  // Query on-chain royalties (PLOT on Base — bonding curve reserve)
   let royaltiesEarned = "0";
   let royaltiesClaimed = "0";
+  let royaltiesUnclaimed = "0";
   if (walletInfo?.address) {
     try {
       // getRoyaltyInfo returns (unclaimed, totalClaimed)
@@ -138,8 +143,9 @@ dashboard.get("/", async (c) => {
         args: [walletInfo.address as `0x${string}`, RESERVE_TOKEN],
       }) as [bigint, bigint];
       // Total earned = unclaimed + previously claimed
-      royaltiesEarned = (Number(unclaimed + totalClaimed) / 1e18).toFixed(6);
-      royaltiesClaimed = (Number(totalClaimed) / 1e18).toFixed(6);
+      royaltiesEarned = formatPlot(unclaimed + totalClaimed);
+      royaltiesClaimed = formatPlot(totalClaimed);
+      royaltiesUnclaimed = formatPlot(unclaimed);
     } catch { /* no royalties or contract not available */ }
   }
 
@@ -219,7 +225,7 @@ dashboard.get("/", async (c) => {
     royalties: {
       earned: royaltiesEarned,
       claimed: royaltiesClaimed,
-      unclaimed: (parseFloat(royaltiesEarned) - parseFloat(royaltiesClaimed)).toFixed(6),
+      unclaimed: royaltiesUnclaimed,
       token: "PLOT",
     },
     pnl: {
@@ -233,4 +239,65 @@ dashboard.get("/", async (c) => {
   });
 });
 
+/** POST /api/dashboard/royalties/claim — claim active wallet PLOT royalties */
+dashboard.post("/royalties/claim", async (c) => {
+  try {
+    const resolved = await resolveActiveWallet();
+    const activeWallet = resolved.activeWallet;
+    const address = activeWallet?.address as Address | undefined;
+
+    if (!activeWallet || !address) {
+      return c.json({
+        error: resolved.error || "No active OWS wallet selected",
+        selectionRequired: resolved.selectionRequired,
+        wallets: resolved.wallets,
+      }, 400);
+    }
+
+    const [unclaimed] = await publicClient.readContract({
+      address: MCV2_BOND,
+      abi: mcv2BondAbi,
+      functionName: "getRoyaltyInfo",
+      args: [address, RESERVE_TOKEN],
+    }) as [bigint, bigint];
+
+    if (unclaimed <= 0n) {
+      return c.json({ error: "No PLOT royalties available to claim", unclaimed: "0", token: "PLOT" }, 400);
+    }
+
+    const rpcUrl = process.env.NEXT_PUBLIC_RPC_URL || "https://mainnet.base.org";
+    const account = createOwsAccount(activeWallet.name, address);
+    const walletClient = createWalletClient({
+      account,
+      chain: base,
+      transport: http(rpcUrl),
+    });
+
+    const { request } = await publicClient.simulateContract({
+      account,
+      address: MCV2_BOND,
+      abi: mcv2BondAbi,
+      functionName: "claimRoyalties",
+      args: [RESERVE_TOKEN],
+    });
+    const txHash = await walletClient.writeContract(request);
+    const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
+
+    if (receipt.status !== "success") {
+      return c.json({ error: "Royalty claim transaction reverted", txHash }, 500);
+    }
+
+    return c.json({
+      ok: true,
+      txHash,
+      amount: formatPlot(unclaimed),
+      token: "PLOT",
+      basescanUrl: `https://basescan.org/tx/${txHash}`,
+    });
+  } catch (err: unknown) {
+    const message = err instanceof Error ? err.message : "Royalty claim failed";
+    return c.json({ error: message }, 500);
+  }
+});
+
 export { dashboard as dashboardRoutes };

package/app/routes/wallet.ts

@@ -1,12 +1,87 @@
 import { Hono } from "hono";
 import fs from "fs";
+import {
+  createPublicClient,
+  createWalletClient,
+  encodeFunctionData,
+  erc20Abi,
+  formatUnits,
+  http,
+  isAddress,
+  parseUnits,
+  type Address,
+} from "viem";
+import { base } from "viem/chains";
 import { ENV_FILE } from "../lib/paths";
 import { nextPlotlinkWalletName, resolveActiveWallet, selectActiveWallet, toPublicActiveWallet } from "../lib/active-wallet";
+import { createOwsAccount } from "../lib/publish";
 
 const envPath = ENV_FILE;
+const rpcUrl = process.env.NEXT_PUBLIC_RPC_URL || "https://mainnet.base.org";
+const USDC_BASE = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913" as const;
+const PLOT_BASE = "0x4F567DACBF9D15A6acBe4A47FC2Ade0719Fb63C4" as const;
+
+const publicClient = createPublicClient({
+  chain: base,
+  transport: http(rpcUrl),
+});
 
 const wallet = new Hono();
 
+const KNOWN_TOKENS = {
+  ETH: { symbol: "ETH", decimals: 18, address: null },
+  USDC: { symbol: "USDC", decimals: 6, address: USDC_BASE },
+  PLOT: { symbol: "PLOT", decimals: 18, address: PLOT_BASE },
+} as const;
+
+type SendToken = {
+  symbol: string;
+  decimals: number;
+  address: Address | null;
+};
+
+function amountLooksValid(amount: unknown): amount is string {
+  return typeof amount === "string" && /^(?:0|[1-9]\d*)(?:\.\d+)?$/.test(amount.trim()) && !/^0(?:\.0*)?$/.test(amount.trim());
+}
+
+async function resolveSendToken(rawToken?: string, rawTokenAddress?: string): Promise<SendToken> {
+  const tokenInput = (rawToken || "").trim();
+  const upper = tokenInput.toUpperCase();
+  if (upper in KNOWN_TOKENS) {
+    return KNOWN_TOKENS[upper as keyof typeof KNOWN_TOKENS];
+  }
+
+  const candidate = rawTokenAddress?.trim() || tokenInput;
+  if (!isAddress(candidate)) {
+    throw new Error("Token must be ETH, PLOT, USDC, or a valid ERC-20 address");
+  }
+
+  const address = candidate as Address;
+  const [symbol, decimals] = await Promise.all([
+    publicClient.readContract({ address, abi: erc20Abi, functionName: "symbol" }),
+    publicClient.readContract({ address, abi: erc20Abi, functionName: "decimals" }),
+  ]);
+
+  return {
+    symbol: String(symbol || "TOKEN"),
+    decimals: Number(decimals),
+    address,
+  };
+}
+
+async function erc20Balance(token: Address, owner: Address): Promise<bigint> {
+  return publicClient.readContract({
+    address: token,
+    abi: erc20Abi,
+    functionName: "balanceOf",
+    args: [owner],
+  }) as Promise<bigint>;
+}
+
+function formatGasRequirement(gasCost: bigint): string {
+  return `${formatUnits(gasCost, 18)} ETH`;
+}
+
 function readEnvPassphrase(): string | null {
   if (process.env.OWS_PASSPHRASE) return process.env.OWS_PASSPHRASE;
   try {
@@ -29,8 +104,6 @@ wallet.get("/", async (c) => {
     let ethBalance = "0";
     let usdcBalance = "0";
     let plotBalance = "0";
-    const rpcUrl = process.env.NEXT_PUBLIC_RPC_URL || "https://mainnet.base.org";
-
     if (activeWallet?.address) {
       const addrPadded = "000000000000000000000000" + activeWallet.address.slice(2).toLowerCase();
       const balanceOfSig = "0x70a08231" + addrPadded;
@@ -48,7 +121,6 @@ wallet.get("/", async (c) => {
         }
 
         // USDC balance (6 decimals)
-        const USDC_BASE = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
         const usdcRes = await fetch(rpcUrl, {
           method: "POST",
           headers: { "Content-Type": "application/json" },
@@ -60,11 +132,10 @@ wallet.get("/", async (c) => {
         }
 
         // PLOT balance (18 decimals)
-        const PLOT = "0x4F567DACBF9D15A6acBe4A47FC2Ade0719Fb63C4";
         const plotRes = await fetch(rpcUrl, {
           method: "POST",
           headers: { "Content-Type": "application/json" },
-          body: JSON.stringify({ jsonrpc: "2.0", id: 3, method: "eth_call", params: [{ to: PLOT, data: balanceOfSig }, "latest"] }),
+          body: JSON.stringify({ jsonrpc: "2.0", id: 3, method: "eth_call", params: [{ to: PLOT_BASE, data: balanceOfSig }, "latest"] }),
         });
         const plotData = await plotRes.json() as { result?: string };
         if (plotData.result && plotData.result !== "0x") {
@@ -101,6 +172,119 @@ wallet.get("/", async (c) => {
   }
 });
 
+/** POST /api/wallet/send — send ETH or ERC-20 tokens from the active OWS wallet */
+wallet.post("/send", async (c) => {
+  try {
+    const body = await c.req.json<{ token?: string; tokenAddress?: string; to?: string; amount?: string }>();
+    const to = body.to?.trim();
+    if (!to || !isAddress(to)) {
+      return c.json({ error: "Valid recipient address required" }, 400);
+    }
+    if (!amountLooksValid(body.amount)) {
+      return c.json({ error: "Positive amount required" }, 400);
+    }
+
+    let token: SendToken;
+    try {
+      token = await resolveSendToken(body.token, body.tokenAddress);
+    } catch (err: unknown) {
+      const message = err instanceof Error ? err.message : "Invalid token";
+      return c.json({ error: message }, 400);
+    }
+
+    let amount: bigint;
+    try {
+      amount = parseUnits(body.amount.trim(), token.decimals);
+    } catch {
+      return c.json({ error: `Amount has too many decimals for ${token.symbol}` }, 400);
+    }
+
+    const resolved = await resolveActiveWallet();
+    const activeWallet = resolved.activeWallet;
+    const from = activeWallet?.address as Address | undefined;
+    if (!activeWallet || !from || !activeWallet.name) {
+      return c.json({
+        error: resolved.error || "No active OWS wallet selected",
+        selectionRequired: resolved.selectionRequired,
+        wallets: resolved.wallets,
+      }, 400);
+    }
+
+    const ethBalance = await publicClient.getBalance({ address: from });
+    const account = createOwsAccount(activeWallet.name, from);
+    const walletClient = createWalletClient({
+      account,
+      chain: base,
+      transport: http(rpcUrl),
+    });
+
+    let txHash: `0x${string}`;
+    if (!token.address) {
+      const gas = await publicClient.estimateGas({ account, to: to as Address, value: amount });
+      const gasPrice = await publicClient.getGasPrice();
+      const gasCost = gas * gasPrice;
+      if (ethBalance < amount + gasCost) {
+        return c.json({
+          error: `Insufficient ETH for amount plus gas. Estimated gas: ${formatGasRequirement(gasCost)}`,
+        }, 400);
+      }
+      txHash = await walletClient.sendTransaction({ to: to as Address, value: amount });
+    } else {
+      const balance = await erc20Balance(token.address, from);
+      if (balance < amount) {
+        return c.json({
+          error: `Insufficient ${token.symbol} balance`,
+          available: formatUnits(balance, token.decimals),
+          required: body.amount.trim(),
+          token: token.symbol,
+        }, 400);
+      }
+
+      const data = encodeFunctionData({
+        abi: erc20Abi,
+        functionName: "transfer",
+        args: [to as Address, amount],
+      });
+      const gas = await publicClient.estimateGas({ account, to: token.address, data });
+      const gasPrice = await publicClient.getGasPrice();
+      const gasCost = gas * gasPrice;
+      if (ethBalance < gasCost) {
+        return c.json({
+          error: `Insufficient ETH for transfer gas. Estimated gas: ${formatGasRequirement(gasCost)}`,
+        }, 400);
+      }
+
+      const { request } = await publicClient.simulateContract({
+        account,
+        address: token.address,
+        abi: erc20Abi,
+        functionName: "transfer",
+        args: [to as Address, amount],
+      });
+      txHash = await walletClient.writeContract(request);
+    }
+
+    const receipt = await publicClient.waitForTransactionReceipt({ hash: txHash });
+    if (receipt.status !== "success") {
+      return c.json({ error: "Transfer transaction reverted", txHash }, 500);
+    }
+
+    return c.json({
+      ok: true,
+      txHash,
+      from,
+      to,
+      token: token.symbol,
+      tokenAddress: token.address,
+      amount: formatUnits(amount, token.decimals),
+      basescanUrl: `https://basescan.org/tx/${txHash}`,
+    });
+  } catch (err: unknown) {
+    const message = err instanceof Error ? err.message : "Wallet transfer failed";
+    return c.json({ error: message }, 500);
+  }
+});
+
 /** POST /api/wallet/active — select active OWS wallet */
 wallet.post("/active", async (c) => {
   const body = await c.req.json<{ walletId?: string; name?: string; address?: string }>();

package/app/web/components/CartoonWorkflowNav.tsx

@@ -3,9 +3,9 @@
  *
  * A normal webtoon creator should not need the file tree: this compact tab bar
  * sits above the right-panel content whenever a CARTOON story is selected and
- * routes between the workflow pages — Progress, Story Info, Whitepaper, Genesis /
- * Episode 1, Episodes, Publish. The left file tree stays for power users; opening
- * a file directly just reflects the closest workflow tab here.
+ * routes between the workflow pages — Progress, Story Info, Episodes, Publish.
+ * Episode files are selected from the left story browser; opening any episode
+ * keeps the workflow tab on Episodes.
  *
  * Fiction renders no nav (the caller only mounts this for cartoon stories), so
  * the fiction UX is unchanged.
@@ -14,16 +14,12 @@
 export type CartoonWorkflowTab =
   | "progress"
   | "story-info"
-  | "whitepaper"
-  | "genesis"
   | "episodes"
   | "publish";
 
 const TABS: { key: CartoonWorkflowTab; label: string }[] = [
   { key: "progress", label: "Progress" },
   { key: "story-info", label: "Story Info" },
-  { key: "whitepaper", label: "Whitepaper" },
-  { key: "genesis", label: "Genesis / Ep 1" },
   { key: "episodes", label: "Episodes" },
   { key: "publish", label: "Publish" },
 ];