@wopr-network/platform-core 1.58.1 → 1.60.0

package/scripts/seed-products.ts

@@ -0,0 +1,268 @@
+/**
+ * Seed product config tables with data for all 4 products.
+ *
+ * Usage:
+ *   DATABASE_URL=postgres://... npx tsx scripts/seed-products.ts
+ *   DATABASE_URL=postgres://... npx tsx scripts/seed-products.ts --slug=paperclip
+ */
+import { eq } from "drizzle-orm";
+import { drizzle } from "drizzle-orm/node-postgres";
+import pg from "pg";
+import { productFeatures, productFleetConfig } from "../src/db/schema/product-config.js";
+import { productNavItems, products } from "../src/db/schema/products.js";
+
+interface NavItem {
+  label: string;
+  href: string;
+  sortOrder: number;
+  requiresRole?: string;
+}
+
+interface FleetPreset {
+  containerImage: string;
+  lifecycle: "managed" | "ephemeral";
+  billingModel: "monthly" | "per_use" | "none";
+  maxInstances: number;
+}
+
+interface ProductPreset {
+  brandName: string;
+  productName: string;
+  tagline: string;
+  domain: string;
+  appDomain: string;
+  cookieDomain: string;
+  companyLegal: string;
+  priceLabel: string;
+  defaultImage: string;
+  emailSupport: string;
+  emailPrivacy: string;
+  emailLegal: string;
+  fromEmail: string;
+  homePath: string;
+  storagePrefix: string;
+  navItems: NavItem[];
+  fleet: FleetPreset;
+}
+
+const PRESETS: Record<string, ProductPreset> = {
+  wopr: {
+    brandName: "WOPR",
+    productName: "WOPR Bot",
+    tagline: "A $5/month supercomputer that manages your business.",
+    domain: "wopr.bot",
+    appDomain: "app.wopr.bot",
+    cookieDomain: ".wopr.bot",
+    companyLegal: "WOPR Network Inc.",
+    priceLabel: "$5/month",
+    defaultImage: "ghcr.io/wopr-network/wopr:latest",
+    emailSupport: "support@wopr.bot",
+    emailPrivacy: "privacy@wopr.bot",
+    emailLegal: "legal@wopr.bot",
+    fromEmail: "noreply@wopr.bot",
+    homePath: "/marketplace",
+    storagePrefix: "wopr",
+    navItems: [
+      { label: "Dashboard", href: "/dashboard", sortOrder: 0 },
+      { label: "Chat", href: "/chat", sortOrder: 1 },
+      { label: "Marketplace", href: "/marketplace", sortOrder: 2 },
+      { label: "Channels", href: "/channels", sortOrder: 3 },
+      { label: "Plugins", href: "/plugins", sortOrder: 4 },
+      { label: "Instances", href: "/instances", sortOrder: 5 },
+      { label: "Changesets", href: "/changesets", sortOrder: 6 },
+      { label: "Network", href: "/dashboard/network", sortOrder: 7 },
+      { label: "Fleet Health", href: "/fleet/health", sortOrder: 8 },
+      { label: "Credits", href: "/billing/credits", sortOrder: 9 },
+      { label: "Billing", href: "/billing/plans", sortOrder: 10 },
+      { label: "Settings", href: "/settings/profile", sortOrder: 11 },
+      { label: "Admin", href: "/admin/tenants", sortOrder: 12, requiresRole: "platform_admin" },
+    ],
+    fleet: {
+      containerImage: "ghcr.io/wopr-network/wopr:latest",
+      lifecycle: "managed",
+      billingModel: "monthly",
+      maxInstances: 5,
+    },
+  },
+  paperclip: {
+    brandName: "Paperclip",
+    productName: "Paperclip",
+    tagline: "AI agents that run your business.",
+    domain: "runpaperclip.com",
+    appDomain: "app.runpaperclip.com",
+    cookieDomain: ".runpaperclip.com",
+    companyLegal: "Paperclip AI Inc.",
+    priceLabel: "$5/month",
+    defaultImage: "ghcr.io/wopr-network/paperclip:managed",
+    emailSupport: "support@runpaperclip.com",
+    emailPrivacy: "privacy@runpaperclip.com",
+    emailLegal: "legal@runpaperclip.com",
+    fromEmail: "noreply@runpaperclip.com",
+    homePath: "/instances",
+    storagePrefix: "paperclip",
+    navItems: [
+      { label: "Instances", href: "/instances", sortOrder: 0 },
+      { label: "Credits", href: "/billing/credits", sortOrder: 1 },
+      { label: "Settings", href: "/settings/profile", sortOrder: 2 },
+      { label: "Admin", href: "/admin/tenants", sortOrder: 3, requiresRole: "platform_admin" },
+    ],
+    fleet: {
+      containerImage: "ghcr.io/wopr-network/paperclip:managed",
+      lifecycle: "managed",
+      billingModel: "monthly",
+      maxInstances: 5,
+    },
+  },
+  holyship: {
+    brandName: "Holy Ship",
+    productName: "Holy Ship",
+    tagline: "Ship it.",
+    domain: "holyship.wtf",
+    appDomain: "app.holyship.wtf",
+    cookieDomain: ".holyship.wtf",
+    companyLegal: "WOPR Network Inc.",
+    priceLabel: "",
+    defaultImage: "ghcr.io/wopr-network/holyship:latest",
+    emailSupport: "support@holyship.wtf",
+    emailPrivacy: "privacy@holyship.wtf",
+    emailLegal: "legal@holyship.wtf",
+    fromEmail: "noreply@holyship.wtf",
+    homePath: "/dashboard",
+    storagePrefix: "holyship",
+    navItems: [
+      { label: "Dashboard", href: "/dashboard", sortOrder: 0 },
+      { label: "Ship", href: "/ship", sortOrder: 1 },
+      { label: "Approvals", href: "/approvals", sortOrder: 2 },
+      { label: "Connect", href: "/connect", sortOrder: 3 },
+      { label: "Credits", href: "/billing/credits", sortOrder: 4 },
+      { label: "Settings", href: "/settings/profile", sortOrder: 5 },
+      { label: "Admin", href: "/admin/tenants", sortOrder: 6, requiresRole: "platform_admin" },
+    ],
+    fleet: {
+      containerImage: "ghcr.io/wopr-network/holyship:latest",
+      lifecycle: "ephemeral",
+      billingModel: "none",
+      maxInstances: 50,
+    },
+  },
+  nemoclaw: {
+    brandName: "NemoPod",
+    productName: "NemoPod",
+    tagline: "NVIDIA NeMo, one click away",
+    domain: "nemopod.com",
+    appDomain: "app.nemopod.com",
+    cookieDomain: ".nemopod.com",
+    companyLegal: "WOPR Network Inc.",
+    priceLabel: "$5 free credits",
+    defaultImage: "ghcr.io/wopr-network/nemoclaw:latest",
+    emailSupport: "support@nemopod.com",
+    emailPrivacy: "privacy@nemopod.com",
+    emailLegal: "legal@nemopod.com",
+    fromEmail: "noreply@nemopod.com",
+    homePath: "/instances",
+    storagePrefix: "nemopod",
+    navItems: [
+      { label: "NemoClaws", href: "/instances", sortOrder: 0 },
+      { label: "Credits", href: "/billing/credits", sortOrder: 1 },
+      { label: "Settings", href: "/settings/profile", sortOrder: 2 },
+      { label: "Admin", href: "/admin/tenants", sortOrder: 3, requiresRole: "platform_admin" },
+    ],
+    fleet: {
+      containerImage: "ghcr.io/wopr-network/nemoclaw:latest",
+      lifecycle: "managed",
+      billingModel: "monthly",
+      maxInstances: 5,
+    },
+  },
+};
+
+async function seed(): Promise<void> {
+  const dbUrl = process.env.DATABASE_URL;
+  if (!dbUrl) {
+    console.error("DATABASE_URL is required");
+    process.exit(1);
+  }
+
+  const slugArg = process.argv.find((a) => a.startsWith("--slug="))?.split("=")[1];
+  const slugs = slugArg ? [slugArg] : Object.keys(PRESETS);
+
+  const pool = new pg.Pool({ connectionString: dbUrl });
+  const db = drizzle(pool);
+
+  for (const slug of slugs) {
+    const preset = PRESETS[slug];
+    if (!preset) {
+      console.error(`Unknown product: ${slug}. Valid: ${Object.keys(PRESETS).join(", ")}`);
+      continue;
+    }
+
+    console.log(`Seeding ${slug}...`);
+    const { navItems, fleet, ...productData } = preset;
+
+    // Upsert product
+    const [product] = await db
+      .insert(products)
+      .values({ slug, ...productData })
+      .onConflictDoUpdate({
+        target: products.slug,
+        set: { ...productData, updatedAt: new Date() },
+      })
+      .returning();
+
+    if (!product) {
+      throw new Error(`Failed to upsert product: ${slug}`);
+    }
+
+    // Replace nav items
+    await db.delete(productNavItems).where(eq(productNavItems.productId, product.id));
+    if (navItems.length > 0) {
+      await db.insert(productNavItems).values(
+        navItems.map((item) => ({
+          productId: product.id,
+          label: item.label,
+          href: item.href,
+          sortOrder: item.sortOrder,
+          requiresRole: item.requiresRole ?? null,
+          enabled: true,
+        })),
+      );
+    }
+
+    // Upsert fleet config
+    await db
+      .insert(productFleetConfig)
+      .values({
+        productId: product.id,
+        containerImage: fleet.containerImage,
+        lifecycle: fleet.lifecycle,
+        billingModel: fleet.billingModel,
+        maxInstances: fleet.maxInstances,
+      })
+      .onConflictDoUpdate({
+        target: productFleetConfig.productId,
+        set: {
+          containerImage: fleet.containerImage,
+          lifecycle: fleet.lifecycle,
+          billingModel: fleet.billingModel,
+          maxInstances: fleet.maxInstances,
+          updatedAt: new Date(),
+        },
+      });
+
+    // Upsert default features (no-op if already exists)
+    await db
+      .insert(productFeatures)
+      .values({ productId: product.id })
+      .onConflictDoNothing();
+
+    console.log(`  done (${navItems.length} nav items, fleet: ${fleet.lifecycle}/${fleet.billingModel})`);
+  }
+
+  await pool.end();
+  console.log("Seed complete.");
+}
+
+seed().catch((err: unknown) => {
+  console.error("Seed failed:", err);
+  process.exit(1);
+});

package/src/billing/crypto/__tests__/key-server.test.ts

@@ -16,6 +16,7 @@ function createMockDb() {
     decimals: 8,
     addressType: "bech32",
     encodingParams: '{"hrp":"bc"}',
+    watcherType: "utxo",
     confirmations: 6,
   };
 
@@ -197,6 +198,7 @@ describe("key-server routes", () => {
       decimals: 18,
       addressType: "evm",
       encodingParams: "{}",
+      watcherType: "evm",
       confirmations: 1,
     };
 
@@ -261,6 +263,7 @@ describe("key-server routes", () => {
       decimals: 18,
       addressType: "evm",
       encodingParams: "{}",
+      watcherType: "evm",
       confirmations: 1,
     };
 

package/src/billing/crypto/key-server.ts

@@ -322,6 +322,7 @@ export function createKeyServerApp(deps: KeyServerDeps): Hono {
       oracle_address?: string;
       address_type?: string;
       encoding_params?: Record<string, string>;
+      watcher_type?: string;
       icon_url?: string;
       display_order?: number;
     }>();
@@ -375,6 +376,7 @@ export function createKeyServerApp(deps: KeyServerDeps): Hono {
       xpub: body.xpub,
       addressType: body.address_type ?? "evm",
       encodingParams: JSON.stringify(body.encoding_params ?? {}),
+      watcherType: body.watcher_type ?? "evm",
       confirmations: body.confirmations ?? 6,
     });
 

package/src/billing/crypto/oracle/coingecko.ts

@@ -14,6 +14,7 @@ const COINGECKO_IDS: Record<string, string> = {
   LINK: "chainlink",
   UNI: "uniswap",
   AERO: "aerodrome-finance",
+  TRX: "tron",
 };
 
 /** Default cache TTL: 60 seconds. CoinGecko free tier allows 10-30 req/min. */

package/src/billing/crypto/payment-method-store.ts

@@ -18,6 +18,7 @@ export interface PaymentMethodRecord {
   xpub: string | null;
   addressType: string;
   encodingParams: string;
+  watcherType: string;
   confirmations: number;
 }
 
@@ -91,6 +92,7 @@ export class DrizzlePaymentMethodStore implements IPaymentMethodStore {
         xpub: method.xpub,
         addressType: method.addressType,
         encodingParams: method.encodingParams,
+        watcherType: method.watcherType,
         confirmations: method.confirmations,
       })
       .onConflictDoUpdate({
@@ -110,6 +112,7 @@ export class DrizzlePaymentMethodStore implements IPaymentMethodStore {
           xpub: method.xpub,
           addressType: method.addressType,
           encodingParams: method.encodingParams,
+          watcherType: method.watcherType,
           confirmations: method.confirmations,
         },
       });
@@ -152,6 +155,7 @@ function toRecord(row: typeof paymentMethods.$inferSelect): PaymentMethodRecord
     xpub: row.xpub,
     addressType: row.addressType,
     encodingParams: row.encodingParams,
+    watcherType: row.watcherType,
     confirmations: row.confirmations,
   };
 }

package/src/billing/crypto/tron/__tests__/address-convert.test.ts

@@ -0,0 +1,67 @@
+import { describe, expect, it } from "vitest";
+import { hexToTron, isTronAddress, tronToHex } from "../address-convert.js";
+
+// Known Tron address / hex pair (Tron foundation address)
+const TRON_ADDR = "TJCnKsPa7y5okkXvQAidZBzqx3QyQ6sxMW";
+const HEX_ADDR = "0x5a523b449890854c8fc460ab602df9f31fe4293f";
+
+describe("tronToHex", () => {
+  it("converts T... to 0x hex", () => {
+    const hex = tronToHex(TRON_ADDR);
+    expect(hex).toBe(HEX_ADDR);
+  });
+
+  it("rejects non-Tron address", () => {
+    expect(() => tronToHex("0x1234")).toThrow("Not a Tron address");
+  });
+
+  it("rejects invalid checksum", () => {
+    // Flip last character
+    const bad = `${TRON_ADDR.slice(0, -1)}X`;
+    expect(() => tronToHex(bad)).toThrow();
+  });
+});
+
+describe("hexToTron", () => {
+  it("converts 0x hex to T...", () => {
+    const tron = hexToTron(HEX_ADDR);
+    expect(tron).toBe(TRON_ADDR);
+  });
+
+  it("handles hex without 0x prefix", () => {
+    const tron = hexToTron(HEX_ADDR.slice(2));
+    expect(tron).toBe(TRON_ADDR);
+  });
+
+  it("rejects wrong length", () => {
+    expect(() => hexToTron("0x1234")).toThrow("Invalid hex address length");
+  });
+});
+
+describe("roundtrip", () => {
+  it("tronToHex → hexToTron is identity", () => {
+    const hex = tronToHex(TRON_ADDR);
+    const back = hexToTron(hex);
+    expect(back).toBe(TRON_ADDR);
+  });
+
+  it("hexToTron → tronToHex is identity", () => {
+    const tron = hexToTron(HEX_ADDR);
+    const back = tronToHex(tron);
+    expect(back).toBe(HEX_ADDR);
+  });
+});
+
+describe("isTronAddress", () => {
+  it("returns true for T... address", () => {
+    expect(isTronAddress(TRON_ADDR)).toBe(true);
+  });
+
+  it("returns false for 0x address", () => {
+    expect(isTronAddress(HEX_ADDR)).toBe(false);
+  });
+
+  it("returns false for BTC address", () => {
+    expect(isTronAddress("bc1qtest")).toBe(false);
+  });
+});

package/src/billing/crypto/tron/address-convert.ts

@@ -0,0 +1,80 @@
+/**
+ * Tron address conversion — T... Base58Check ↔ 0x hex.
+ *
+ * Tron addresses are 21 bytes: 0x41 prefix + 20-byte address.
+ * The JSON-RPC layer strips the 0x41 and returns standard 0x-prefixed hex.
+ * We need to convert between the two at the watcher boundary.
+ */
+import { sha256 } from "@noble/hashes/sha2.js";
+
+const BASE58_ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+
+function base58decode(s: string): Uint8Array {
+  let num = 0n;
+  for (const ch of s) {
+    const idx = BASE58_ALPHABET.indexOf(ch);
+    if (idx < 0) throw new Error(`Invalid base58 character: ${ch}`);
+    num = num * 58n + BigInt(idx);
+  }
+  const hex = num.toString(16).padStart(50, "0"); // 25 bytes = 50 hex chars
+  const bytes = new Uint8Array(25);
+  for (let i = 0; i < 25; i++) bytes[i] = Number.parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+  return bytes;
+}
+
+/**
+ * Convert a Tron T... address to 0x hex (20 bytes, no 0x41 prefix).
+ * For feeding addresses to the EVM watcher JSON-RPC filters.
+ */
+export function tronToHex(tronAddr: string): string {
+  if (!tronAddr.startsWith("T")) throw new Error(`Not a Tron address: ${tronAddr}`);
+  const decoded = base58decode(tronAddr);
+  // decoded: [0x41, ...20 bytes address..., ...4 bytes checksum]
+  // Verify checksum
+  const payload = decoded.slice(0, 21);
+  const checksum = sha256(sha256(payload)).slice(0, 4);
+  for (let i = 0; i < 4; i++) {
+    if (decoded[21 + i] !== checksum[i]) throw new Error(`Invalid checksum for Tron address: ${tronAddr}`);
+  }
+  // Strip 0x41 prefix, return 20-byte hex with 0x prefix
+  const addrBytes = payload.slice(1);
+  return `0x${Array.from(addrBytes, (b) => b.toString(16).padStart(2, "0")).join("")}`;
+}
+
+/**
+ * Convert a 0x hex address (20 bytes) back to Tron T... Base58Check.
+ * For converting watcher event addresses back to DB format.
+ */
+export function hexToTron(hexAddr: string): string {
+  const hex = hexAddr.startsWith("0x") ? hexAddr.slice(2) : hexAddr;
+  if (hex.length !== 40) throw new Error(`Invalid hex address length: ${hex.length}`);
+  // Build payload: 0x41 + 20 bytes
+  const payload = new Uint8Array(21);
+  payload[0] = 0x41;
+  for (let i = 0; i < 20; i++) payload[i + 1] = Number.parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+  // Compute checksum
+  const checksum = sha256(sha256(payload)).slice(0, 4);
+  const full = new Uint8Array(25);
+  full.set(payload);
+  full.set(checksum, 21);
+  // Base58 encode
+  let num = 0n;
+  for (const byte of full) num = num * 256n + BigInt(byte);
+  let encoded = "";
+  while (num > 0n) {
+    encoded = BASE58_ALPHABET[Number(num % 58n)] + encoded;
+    num = num / 58n;
+  }
+  for (const byte of full) {
+    if (byte !== 0) break;
+    encoded = `1${encoded}`;
+  }
+  return encoded;
+}
+
+/**
+ * Check if an address is a Tron T... address.
+ */
+export function isTronAddress(addr: string): boolean {
+  return addr.startsWith("T") && addr.length >= 33 && addr.length <= 35;
+}

package/src/billing/crypto/watcher-service.ts

@@ -25,6 +25,7 @@ import type { EvmChain, EvmPaymentEvent, StablecoinToken } from "./evm/types.js"
 import { createRpcCaller, EvmWatcher } from "./evm/watcher.js";
 import type { IPriceOracle } from "./oracle/types.js";
 import type { IPaymentMethodStore } from "./payment-method-store.js";
+import { hexToTron, isTronAddress, tronToHex } from "./tron/address-convert.js";
 import type { CryptoChargeStatus } from "./types.js";
 
 const MAX_DELIVERY_ATTEMPTS = 10;
@@ -252,14 +253,10 @@ export async function startWatchers(opts: WatcherServiceOpts): Promise<() => voi
 
   const methods = await methodStore.listEnabled();
 
-  const utxoMethods = methods.filter(
-    (m) => m.type === "native" && (m.chain === "bitcoin" || m.chain === "litecoin" || m.chain === "dogecoin"),
-  );
-  const evmMethods = methods.filter(
-    (m) =>
-      m.type === "erc20" ||
-      (m.type === "native" && m.chain !== "bitcoin" && m.chain !== "litecoin" && m.chain !== "dogecoin"),
-  );
+  // Route watchers by DB-driven watcherType — no hardcoded chain names.
+  // Adding a new chain is a DB INSERT with watcher_type = "utxo" or "evm".
+  const utxoMethods = methods.filter((m) => m.watcherType === "utxo");
+  const evmMethods = methods.filter((m) => m.watcherType === "evm");
 
   // --- UTXO Watchers (BTC, LTC, DOGE) ---
   for (const method of utxoMethods) {
@@ -363,6 +360,15 @@ export async function startWatchers(opts: WatcherServiceOpts): Promise<() => voi
 
   const BACKFILL_BLOCKS = 1000; // Scan ~30min of blocks on first deploy to catch missed deposits
 
+  // Address conversion helpers for chains with non-EVM address formats (e.g. Tron T...).
+  // The EVM watcher uses 0x hex addresses; the DB stores native format (T... for Tron).
+  // Determined by addressType from the DB — not by inspecting addresses at runtime.
+  const needsAddrConvert = (method: { addressType: string }): boolean => method.addressType === "p2pkh";
+  const toWatcherAddr = (addr: string, method: { addressType: string }): string =>
+    needsAddrConvert(method) && isTronAddress(addr) ? tronToHex(addr) : addr;
+  const fromWatcherAddr = (addr: string, method: { addressType: string }): string =>
+    needsAddrConvert(method) ? hexToTron(addr) : addr;
+
   for (const method of nativeEvmMethods) {
     if (!method.rpcUrl) continue;
 
@@ -382,13 +388,14 @@ export async function startWatchers(opts: WatcherServiceOpts): Promise<() => voi
       rpcCall,
       oracle,
       fromBlock: backfillStart,
-      watchedAddresses: chainAddresses,
+      watchedAddresses: chainAddresses.map((a) => toWatcherAddr(a, method)),
       cursorStore,
       confirmations: method.confirmations,
       onPayment: async (event: EthPaymentEvent) => {
+        const dbAddr = fromWatcherAddr(event.to, method);
         log("ETH payment", {
           chain: event.chain,
-          to: event.to,
+          to: dbAddr,
           txHash: event.txHash,
           valueWei: event.valueWei,
           confirmations: event.confirmations,
@@ -397,7 +404,7 @@ export async function startWatchers(opts: WatcherServiceOpts): Promise<() => voi
         await handlePayment(
           db,
           chargeStore,
-          event.to,
+          dbAddr,
           event.valueWei,
           {
             txHash: event.txHash,
@@ -423,7 +430,7 @@ export async function startWatchers(opts: WatcherServiceOpts): Promise<() => voi
           const freshNative = fresh
             .filter((a) => a.chain === method.chain && a.token === method.token)
             .map((a) => a.address);
-          watcher.setWatchedAddresses(freshNative);
+          watcher.setWatchedAddresses(freshNative.map((a) => toWatcherAddr(a, method)));
           await watcher.poll();
         } catch (err) {
           log("ETH poll error", { chain: method.chain, error: String(err) });
@@ -450,16 +457,17 @@ export async function startWatchers(opts: WatcherServiceOpts): Promise<() => voi
       token: method.token as StablecoinToken,
       rpcCall,
       fromBlock: latestBlock,
-      watchedAddresses: chainAddresses,
+      watchedAddresses: chainAddresses.map((a) => toWatcherAddr(a, method)),
       contractAddress: method.contractAddress,
       decimals: method.decimals,
       confirmations: method.confirmations,
       cursorStore,
       onPayment: async (event: EvmPaymentEvent) => {
+        const dbAddr = fromWatcherAddr(event.to, method);
         log("EVM payment", {
           chain: event.chain,
           token: event.token,
-          to: event.to,
+          to: dbAddr,
           txHash: event.txHash,
           confirmations: event.confirmations,
           confirmationsRequired: event.confirmationsRequired,
@@ -467,7 +475,7 @@ export async function startWatchers(opts: WatcherServiceOpts): Promise<() => voi
         await handlePayment(
           db,
           chargeStore,
-          event.to,
+          dbAddr,
           event.rawAmount,
           {
             txHash: event.txHash,
@@ -491,7 +499,7 @@ export async function startWatchers(opts: WatcherServiceOpts): Promise<() => voi
         try {
           const fresh = await chargeStore.listActiveDepositAddresses();
           const freshChain = fresh.filter((a) => a.chain === method.chain).map((a) => a.address);
-          watcher.setWatchedAddresses(freshChain);
+          watcher.setWatchedAddresses(freshChain.map((a) => toWatcherAddr(a, method)));
           await watcher.poll();
         } catch (err) {
           log("EVM poll error", { chain: method.chain, token: method.token, error: String(err) });

package/src/db/schema/crypto.ts

@@ -84,6 +84,7 @@ export const paymentMethods = pgTable("payment_methods", {
   xpub: text("xpub"), // HD wallet extended public key for deposit address derivation
   addressType: text("address_type").notNull().default("evm"), // "bech32" (BTC/LTC), "p2pkh" (DOGE), "evm" (ETH/ERC20)
   encodingParams: text("encoding_params").notNull().default("{}"), // JSON: {"hrp":"bc"}, {"version":"0x1e"}, etc.
+  watcherType: text("watcher_type").notNull().default("evm"), // "utxo" (BTC/LTC/DOGE) or "evm" (ETH/ERC20/TRX)
   confirmations: integer("confirmations").notNull().default(1),
   nextIndex: integer("next_index").notNull().default(0), // atomic derivation counter, never reuses
   createdAt: text("created_at").notNull().default(sql`(now())`),

package/src/db/schema/index.ts

@@ -44,6 +44,8 @@ export * from "./page-contexts.js";
 export * from "./platform-api-keys.js";
 export * from "./plugin-configs.js";
 export * from "./plugin-marketplace-content.js";
+export * from "./product-config.js";
+export * from "./products.js";
 export * from "./promotion-redemptions.js";
 export * from "./promotions.js";
 export * from "./provider-credentials.js";