@wopr-network/platform-core 1.25.0 → 1.27.0

package/src/billing/crypto/unified-checkout.ts

@@ -0,0 +1,190 @@
+import { Credit } from "../../credits/credit.js";
+import type { ICryptoChargeRepository } from "./charge-store.js";
+import { deriveDepositAddress } from "./evm/address-gen.js";
+import { centsToNative } from "./oracle/convert.js";
+import type { IPriceOracle } from "./oracle/types.js";
+import type { PaymentMethodRecord } from "./payment-method-store.js";
+
+export const MIN_CHECKOUT_USD = 10;
+
+export interface UnifiedCheckoutDeps {
+  chargeStore: Pick<ICryptoChargeRepository, "getNextDerivationIndex" | "createStablecoinCharge">;
+  oracle: IPriceOracle;
+  evmXpub: string;
+  btcXpub?: string;
+}
+
+export interface UnifiedCheckoutResult {
+  depositAddress: string;
+  /** Human-readable amount to send (e.g. "50 USDC", "0.014285 ETH"). */
+  displayAmount: string;
+  amountUsd: number;
+  token: string;
+  chain: string;
+  referenceId: string;
+  /** For volatile assets: price at checkout time (USD cents per unit). */
+  priceCents?: number;
+}
+
+/**
+ * Unified checkout — one entry point for all payment methods.
+ *
+ * Looks up the method record, routes by type:
+ *   - erc20: derives EVM address, computes token amount (1:1 USD for stablecoins)
+ *   - native (ETH): derives EVM address, oracle-priced
+ *   - native (BTC): derives BTC address, oracle-priced
+ *
+ * CRITICAL: amountUsd → integer cents via Credit.fromDollars().toCentsRounded().
+ */
+export async function createUnifiedCheckout(
+  deps: UnifiedCheckoutDeps,
+  method: PaymentMethodRecord,
+  opts: { tenant: string; amountUsd: number },
+): Promise<UnifiedCheckoutResult> {
+  if (!Number.isFinite(opts.amountUsd) || opts.amountUsd < MIN_CHECKOUT_USD) {
+    throw new Error(`Minimum payment amount is $${MIN_CHECKOUT_USD}`);
+  }
+
+  const amountUsdCents = Credit.fromDollars(opts.amountUsd).toCentsRounded();
+
+  if (method.type === "erc20") {
+    return handleErc20(deps, method, opts.tenant, amountUsdCents, opts.amountUsd);
+  }
+  if (method.token === "ETH") {
+    return handleNativeEth(deps, method, opts.tenant, amountUsdCents, opts.amountUsd);
+  }
+  if (method.token === "BTC") {
+    return handleNativeBtc(deps, method, opts.tenant, amountUsdCents, opts.amountUsd);
+  }
+
+  throw new Error(`Unsupported payment method type: ${method.type}/${method.token}`);
+}
+
+async function handleErc20(
+  deps: UnifiedCheckoutDeps,
+  method: PaymentMethodRecord,
+  tenant: string,
+  amountUsdCents: number,
+  amountUsd: number,
+): Promise<UnifiedCheckoutResult> {
+  const depositAddress = await deriveAndStore(deps, method, tenant, amountUsdCents);
+
+  return {
+    depositAddress,
+    displayAmount: `${amountUsd} ${method.token}`,
+    amountUsd,
+    token: method.token,
+    chain: method.chain,
+    referenceId: `erc20:${method.chain}:${depositAddress}`,
+  };
+}
+
+async function handleNativeEth(
+  deps: UnifiedCheckoutDeps,
+  method: PaymentMethodRecord,
+  tenant: string,
+  amountUsdCents: number,
+  amountUsd: number,
+): Promise<UnifiedCheckoutResult> {
+  const { priceCents } = await deps.oracle.getPrice("ETH");
+  const expectedWei = centsToNative(amountUsdCents, priceCents, 18);
+  const depositAddress = await deriveAndStore(deps, method, tenant, amountUsdCents);
+
+  const divisor = BigInt("1000000000000000000");
+  const whole = expectedWei / divisor;
+  const frac = (expectedWei % divisor).toString().padStart(18, "0").slice(0, 6);
+
+  return {
+    depositAddress,
+    displayAmount: `${whole}.${frac} ETH`,
+    amountUsd,
+    token: "ETH",
+    chain: method.chain,
+    referenceId: `eth:${method.chain}:${depositAddress}`,
+    priceCents,
+  };
+}
+
+async function handleNativeBtc(
+  deps: UnifiedCheckoutDeps,
+  _method: PaymentMethodRecord,
+  tenant: string,
+  amountUsdCents: number,
+  amountUsd: number,
+): Promise<UnifiedCheckoutResult> {
+  const { priceCents } = await deps.oracle.getPrice("BTC");
+  const expectedSats = centsToNative(amountUsdCents, priceCents, 8);
+
+  // BTC address derivation uses btcXpub — import from btc module
+  const { deriveBtcAddress } = await import("./btc/address-gen.js");
+  if (!deps.btcXpub) throw new Error("BTC payments not configured (no BTC_XPUB)");
+
+  const maxRetries = 3;
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    const derivationIndex = await deps.chargeStore.getNextDerivationIndex();
+    const depositAddress = deriveBtcAddress(deps.btcXpub, derivationIndex, "mainnet");
+    const referenceId = `btc:${depositAddress}`;
+
+    try {
+      await deps.chargeStore.createStablecoinCharge({
+        referenceId,
+        tenantId: tenant,
+        amountUsdCents,
+        chain: "bitcoin",
+        token: "BTC",
+        depositAddress,
+        derivationIndex,
+      });
+
+      const btcAmount = Number(expectedSats) / 100_000_000;
+      return {
+        depositAddress,
+        displayAmount: `${btcAmount.toFixed(8)} BTC`,
+        amountUsd,
+        token: "BTC",
+        chain: "bitcoin",
+        referenceId,
+        priceCents,
+      };
+    } catch (err: unknown) {
+      const code = (err as { code?: string }).code;
+      const isConflict = code === "23505" || (err instanceof Error && err.message.includes("unique_violation"));
+      if (!isConflict || attempt === maxRetries) throw err;
+    }
+  }
+
+  throw new Error("Failed to claim derivation index after retries");
+}
+
+/** Derive an EVM deposit address and store the charge. Retries on unique conflict. */
+async function deriveAndStore(
+  deps: UnifiedCheckoutDeps,
+  method: PaymentMethodRecord,
+  tenant: string,
+  amountUsdCents: number,
+): Promise<string> {
+  const maxRetries = 3;
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    const derivationIndex = await deps.chargeStore.getNextDerivationIndex();
+    const depositAddress = deriveDepositAddress(deps.evmXpub, derivationIndex);
+    const referenceId = `${method.type}:${method.chain}:${depositAddress}`;
+
+    try {
+      await deps.chargeStore.createStablecoinCharge({
+        referenceId,
+        tenantId: tenant,
+        amountUsdCents,
+        chain: method.chain,
+        token: method.token,
+        depositAddress,
+        derivationIndex,
+      });
+      return depositAddress;
+    } catch (err: unknown) {
+      const code = (err as { code?: string }).code;
+      const isConflict = code === "23505" || (err instanceof Error && err.message.includes("unique_violation"));
+      if (!isConflict || attempt === maxRetries) throw err;
+    }
+  }
+  throw new Error("Failed to claim derivation index after retries");
+}

package/src/db/schema/crypto.ts

@@ -1,5 +1,5 @@
 import { sql } from "drizzle-orm";
-import { index, integer, pgTable, primaryKey, text } from "drizzle-orm/pg-core";
+import { boolean, index, integer, pgTable, primaryKey, text } from "drizzle-orm/pg-core";
 
 /**
  * Crypto payment charges — tracks the lifecycle of each BTCPay invoice.
@@ -46,6 +46,26 @@ export const watcherCursors = pgTable("watcher_cursors", {
   updatedAt: text("updated_at").notNull().default(sql`(now())`),
 });
 
+/**
+ * Payment method registry — runtime-configurable tokens/chains.
+ * Admin inserts a row to enable a new payment method. No deploy needed.
+ * Contract addresses are immutable on-chain but configurable here.
+ */
+export const paymentMethods = pgTable("payment_methods", {
+  id: text("id").primaryKey(), // "USDC:base", "ETH:base", "BTC:mainnet"
+  type: text("type").notNull(), // "stablecoin", "eth", "btc"
+  token: text("token").notNull(), // "USDC", "ETH", "BTC"
+  chain: text("chain").notNull(), // "base", "ethereum", "bitcoin"
+  contractAddress: text("contract_address"), // null for native (ETH, BTC)
+  decimals: integer("decimals").notNull(),
+  displayName: text("display_name").notNull(),
+  enabled: boolean("enabled").notNull().default(true),
+  displayOrder: integer("display_order").notNull().default(0),
+  rpcUrl: text("rpc_url"), // override per-chain RPC (null = use default)
+  confirmations: integer("confirmations").notNull().default(1),
+  createdAt: text("created_at").notNull().default(sql`(now())`),
+});
+
 /** Processed transaction IDs for watchers without block cursors (e.g. BTC). */
 export const watcherProcessed = pgTable(
   "watcher_processed",

package/src/db/schema/index.ts

@@ -64,6 +64,7 @@ export * from "./tenant-capability-settings.js";
 export * from "./tenant-customers.js";
 export * from "./tenant-model-selection.js";
 export * from "./tenant-status.js";
+export * from "./tenant-update-configs.js";
 export * from "./tenants.js";
 export * from "./user-roles.js";
 export * from "./vps-subscriptions.js";

package/src/db/schema/tenant-update-configs.ts

@@ -0,0 +1,16 @@
+import { bigint, integer, pgTable, text } from "drizzle-orm/pg-core";
+
+/**
+ * Per-tenant update configuration — controls whether a tenant's bots
+ * are updated automatically or require manual intervention.
+ */
+export const tenantUpdateConfigs = pgTable("tenant_update_configs", {
+  /** Owning tenant (one config per tenant) */
+  tenantId: text("tenant_id").primaryKey(),
+  /** Update mode: 'auto' for automatic updates, 'manual' for opt-in */
+  mode: text("mode").notNull().default("manual"),
+  /** Preferred hour (0-23 UTC) for automatic updates */
+  preferredHourUtc: integer("preferred_hour_utc").notNull().default(3),
+  /** Epoch ms of last config change */
+  updatedAt: bigint("updated_at", { mode: "number" }).notNull(),
+});

package/src/fleet/__tests__/tenant-update-config-repository.test.ts

@@ -0,0 +1,69 @@
+import type { PGlite } from "@electric-sql/pglite";
+import { afterAll, beforeAll, beforeEach, describe, expect, it } from "vitest";
+import type { DrizzleDb } from "../../db/index.js";
+import { beginTestTransaction, createTestDb, endTestTransaction, rollbackTestTransaction } from "../../test/db.js";
+import { DrizzleTenantUpdateConfigRepository } from "../drizzle-tenant-update-config-repository.js";
+
+describe("DrizzleTenantUpdateConfigRepository", () => {
+  let db: DrizzleDb;
+  let pool: PGlite;
+  let repo: DrizzleTenantUpdateConfigRepository;
+
+  beforeAll(async () => {
+    ({ db, pool } = await createTestDb());
+    await beginTestTransaction(pool);
+  });
+
+  afterAll(async () => {
+    await endTestTransaction(pool);
+    await pool.close();
+  });
+
+  beforeEach(async () => {
+    await rollbackTestTransaction(pool);
+    repo = new DrizzleTenantUpdateConfigRepository(db);
+  });
+
+  it("get returns null for unknown tenant", async () => {
+    expect(await repo.get("nonexistent")).toBeNull();
+  });
+
+  it("upsert creates a new config", async () => {
+    await repo.upsert("tenant-1", { mode: "auto", preferredHourUtc: 5 });
+    const config = await repo.get("tenant-1");
+    expect(config).not.toBeNull();
+    expect(config?.tenantId).toBe("tenant-1");
+    expect(config?.mode).toBe("auto");
+    expect(config?.preferredHourUtc).toBe(5);
+    expect(config?.updatedAt).toBeGreaterThan(0);
+  });
+
+  it("upsert updates an existing config", async () => {
+    await repo.upsert("tenant-1", { mode: "auto", preferredHourUtc: 5 });
+    const before = await repo.get("tenant-1");
+
+    await repo.upsert("tenant-1", { mode: "manual", preferredHourUtc: 12 });
+    const after = await repo.get("tenant-1");
+
+    expect(after?.mode).toBe("manual");
+    expect(after?.preferredHourUtc).toBe(12);
+    expect(after?.updatedAt).toBeGreaterThanOrEqual(before?.updatedAt ?? 0);
+  });
+
+  it("listAutoEnabled returns only auto-mode tenants", async () => {
+    await repo.upsert("tenant-auto-1", { mode: "auto", preferredHourUtc: 3 });
+    await repo.upsert("tenant-auto-2", { mode: "auto", preferredHourUtc: 8 });
+    await repo.upsert("tenant-manual", { mode: "manual", preferredHourUtc: 0 });
+
+    const autoConfigs = await repo.listAutoEnabled();
+    expect(autoConfigs).toHaveLength(2);
+    expect(autoConfigs.every((c) => c.mode === "auto")).toBe(true);
+    expect(autoConfigs.map((c) => c.tenantId).sort()).toEqual(["tenant-auto-1", "tenant-auto-2"]);
+  });
+
+  it("listAutoEnabled returns empty array when none enabled", async () => {
+    await repo.upsert("tenant-manual", { mode: "manual", preferredHourUtc: 0 });
+    const autoConfigs = await repo.listAutoEnabled();
+    expect(autoConfigs).toEqual([]);
+  });
+});

package/src/fleet/drizzle-tenant-update-config-repository.ts

@@ -0,0 +1,48 @@
+import { eq } from "drizzle-orm";
+import type { DrizzleDb } from "../db/index.js";
+import { tenantUpdateConfigs } from "../db/schema/index.js";
+import type { ITenantUpdateConfigRepository, TenantUpdateConfig } from "./tenant-update-config-repository.js";
+
+/** Drizzle-backed implementation of ITenantUpdateConfigRepository. */
+export class DrizzleTenantUpdateConfigRepository implements ITenantUpdateConfigRepository {
+  constructor(private readonly db: DrizzleDb) {}
+
+  async get(tenantId: string): Promise<TenantUpdateConfig | null> {
+    const rows = await this.db.select().from(tenantUpdateConfigs).where(eq(tenantUpdateConfigs.tenantId, tenantId));
+    return rows[0] ? toConfig(rows[0]) : null;
+  }
+
+  async upsert(tenantId: string, config: Omit<TenantUpdateConfig, "tenantId" | "updatedAt">): Promise<void> {
+    const now = Date.now();
+    await this.db
+      .insert(tenantUpdateConfigs)
+      .values({
+        tenantId,
+        mode: config.mode,
+        preferredHourUtc: config.preferredHourUtc,
+        updatedAt: now,
+      })
+      .onConflictDoUpdate({
+        target: tenantUpdateConfigs.tenantId,
+        set: {
+          mode: config.mode,
+          preferredHourUtc: config.preferredHourUtc,
+          updatedAt: now,
+        },
+      });
+  }
+
+  async listAutoEnabled(): Promise<TenantUpdateConfig[]> {
+    const rows = await this.db.select().from(tenantUpdateConfigs).where(eq(tenantUpdateConfigs.mode, "auto"));
+    return rows.map(toConfig);
+  }
+}
+
+function toConfig(row: typeof tenantUpdateConfigs.$inferSelect): TenantUpdateConfig {
+  return {
+    tenantId: row.tenantId,
+    mode: row.mode as "auto" | "manual",
+    preferredHourUtc: row.preferredHourUtc,
+    updatedAt: row.updatedAt,
+  };
+}

package/src/fleet/fleet-event-emitter.ts

@@ -1,7 +1,14 @@
 import { logger } from "../config/logger.js";
 import type { IFleetEventRepository } from "./fleet-event-repository.js";
 
-export type BotEventType = "bot.started" | "bot.stopped" | "bot.created" | "bot.removed" | "bot.restarted";
+export type BotEventType =
+  | "bot.started"
+  | "bot.stopped"
+  | "bot.created"
+  | "bot.removed"
+  | "bot.restarted"
+  | "bot.updated"
+  | "bot.update_failed";
 
 export type NodeEventType =
   | "node.provisioned"

package/src/fleet/index.ts

@@ -1,7 +1,9 @@
+export * from "./drizzle-tenant-update-config-repository.js";
 export * from "./init-fleet-updater.js";
 export * from "./repository-types.js";
 export * from "./rollout-orchestrator.js";
 export * from "./rollout-strategy.js";
 export * from "./services.js";
+export * from "./tenant-update-config-repository.js";
 export * from "./types.js";
 export * from "./volume-snapshot-manager.js";

package/src/fleet/init-fleet-updater.ts

@@ -14,11 +14,13 @@
 import type Docker from "dockerode";
 import { logger } from "../config/logger.js";
 import type { IBotProfileRepository } from "./bot-profile-repository.js";
+import type { FleetEventEmitter } from "./fleet-event-emitter.js";
 import type { FleetManager } from "./fleet-manager.js";
 import { ImagePoller } from "./image-poller.js";
 import type { IProfileStore } from "./profile-store.js";
 import { RolloutOrchestrator, type RolloutResult } from "./rollout-orchestrator.js";
 import { createRolloutStrategy, type RollingWaveOptions } from "./rollout-strategy.js";
+import type { ITenantUpdateConfigRepository } from "./tenant-update-config-repository.js";
 import { ContainerUpdater } from "./updater.js";
 import { VolumeSnapshotManager } from "./volume-snapshot-manager.js";
 
@@ -33,6 +35,10 @@ export interface FleetUpdaterConfig {
   onBotUpdated?: (result: { botId: string; success: boolean; volumeRestored: boolean }) => void;
   /** Called when a rollout completes */
   onRolloutComplete?: (result: RolloutResult) => void;
+  /** Optional per-tenant update config repository. When provided, tenants with mode=manual are excluded. */
+  configRepo?: ITenantUpdateConfigRepository;
+  /** Optional fleet event emitter. When provided, bot.updated / bot.update_failed events are emitted. */
+  eventEmitter?: FleetEventEmitter;
 }
 
 export interface FleetUpdaterHandle {
@@ -69,6 +75,8 @@ export function initFleetUpdater(
     snapshotDir = "/data/fleet/snapshots",
     onBotUpdated,
     onRolloutComplete,
+    configRepo,
+    eventEmitter,
   } = config;
 
   const poller = new ImagePoller(docker, profileStore);
@@ -82,10 +90,37 @@ export function initFleetUpdater(
     strategy,
     getUpdatableProfiles: async () => {
       const profiles = await profileRepo.list();
-      return profiles.filter((p) => p.updatePolicy !== "manual");
+      const nonManualPolicy = profiles.filter((p) => p.updatePolicy !== "manual");
+
+      if (!configRepo) return nonManualPolicy;
+
+      // Filter out tenants whose per-tenant config is set to manual
+      const results = await Promise.all(
+        nonManualPolicy.map(async (p) => {
+          const tenantCfg = await configRepo.get(p.tenantId);
+          // If tenant has an explicit config with mode=manual, exclude
+          if (tenantCfg && tenantCfg.mode === "manual") return null;
+          return p;
+        }),
+      );
+      return results.filter((p) => p !== null);
+    },
+    onBotUpdated: (result) => {
+      // Emit fleet events if emitter is provided
+      if (eventEmitter) {
+        eventEmitter.emit({
+          type: result.success ? "bot.updated" : "bot.update_failed",
+          botId: result.botId,
+          tenantId: "",
+          timestamp: new Date().toISOString(),
+        });
+      }
+      // Chain user-provided callback
+      onBotUpdated?.(result);
+    },
+    onRolloutComplete: (result) => {
+      onRolloutComplete?.(result);
     },
-    onBotUpdated,
-    onRolloutComplete,
   });
 
   // Wire the detection → orchestration pipeline.

package/src/fleet/services.ts

@@ -50,6 +50,7 @@ import { DrizzleBotProfileRepository } from "./drizzle-bot-profile-repository.js
 import { DrizzleFleetEventRepository } from "./drizzle-fleet-event-repository.js";
 import { DrizzleNodeRepository } from "./drizzle-node-repository.js";
 import { DrizzleRecoveryRepository } from "./drizzle-recovery-repository.js";
+import { DrizzleTenantUpdateConfigRepository } from "./drizzle-tenant-update-config-repository.js";
 import { FleetEventEmitter } from "./fleet-event-emitter.js";
 import type { IFleetEventRepository } from "./fleet-event-repository.js";
 import type { IGpuAllocationRepository } from "./gpu-allocation-repository.js";
@@ -76,6 +77,7 @@ import type { IRecoveryRepository } from "./recovery-repository.js";
 import type { IRegistrationTokenRepository } from "./registration-token-store.js";
 import { DrizzleRegistrationTokenRepository } from "./registration-token-store.js";
 import { DrizzleSpendingCapStore } from "./spending-cap-repository.js";
+import type { ITenantUpdateConfigRepository } from "./tenant-update-config-repository.js";
 import type { IVpsRepository } from "./vps-repository.js";
 import { DrizzleVpsRepository } from "./vps-repository.js";
 
@@ -128,6 +130,9 @@ let _fleetEventEmitter: FleetEventEmitter | null = null;
 // Fleet event repository
 let _fleetEventRepo: IFleetEventRepository | null = null;
 
+// Tenant update config
+let _tenantUpdateConfigRepo: ITenantUpdateConfigRepository | null = null;
+
 // Infrastructure
 let _doClient: DOClient | null = null;
 let _nodeProvider: INodeProvider | null = null;
@@ -403,6 +408,13 @@ export function getFleetEventRepo(): IFleetEventRepository {
   return _fleetEventRepo;
 }
 
+export function getTenantUpdateConfigRepo(): ITenantUpdateConfigRepository {
+  if (!_tenantUpdateConfigRepo) {
+    _tenantUpdateConfigRepo = new DrizzleTenantUpdateConfigRepository(getDb());
+  }
+  return _tenantUpdateConfigRepo;
+}
+
 // ---------------------------------------------------------------------------
 // HeartbeatWatchdog
 // ---------------------------------------------------------------------------
@@ -894,6 +906,7 @@ export function _resetForTest(): void {
   _inferenceWatchdog = null;
   _fleetEventRepo = null;
   _fleetEventEmitter = null;
+  _tenantUpdateConfigRepo = null;
   _doClient = null;
   _nodeProvider = null;
   _nodeProvisioner = null;

package/src/fleet/tenant-update-config-repository.ts

@@ -0,0 +1,12 @@
+export interface TenantUpdateConfig {
+  tenantId: string;
+  mode: "auto" | "manual";
+  preferredHourUtc: number;
+  updatedAt: number;
+}
+
+export interface ITenantUpdateConfigRepository {
+  get(tenantId: string): Promise<TenantUpdateConfig | null>;
+  upsert(tenantId: string, config: Omit<TenantUpdateConfig, "tenantId" | "updatedAt">): Promise<void>;
+  listAutoEnabled(): Promise<TenantUpdateConfig[]>;
+}

package/src/trpc/fleet-update-config-router.ts

@@ -0,0 +1,31 @@
+import { z } from "zod";
+import { logger } from "../config/logger.js";
+import type { ITenantUpdateConfigRepository } from "../fleet/tenant-update-config-repository.js";
+import { protectedProcedure, router } from "./init.js";
+
+export function createFleetUpdateConfigRouter(configRepo: ITenantUpdateConfigRepository) {
+  return router({
+    getUpdateConfig: protectedProcedure.input(z.object({ tenantId: z.string().min(1) })).query(async ({ input }) => {
+      return configRepo.get(input.tenantId);
+    }),
+
+    setUpdateConfig: protectedProcedure
+      .input(
+        z.object({
+          tenantId: z.string().min(1),
+          mode: z.enum(["auto", "manual"]),
+          preferredHourUtc: z.number().int().min(0).max(23).optional(),
+        }),
+      )
+      .mutation(async ({ input }) => {
+        await configRepo.upsert(input.tenantId, {
+          mode: input.mode,
+          preferredHourUtc: input.preferredHourUtc ?? 3,
+        });
+        logger.info("Tenant update config changed", {
+          tenantId: input.tenantId,
+          mode: input.mode,
+        });
+      }),
+  });
+}

package/src/trpc/index.ts

@@ -1,3 +1,4 @@
+export { createFleetUpdateConfigRouter } from "./fleet-update-config-router.js";
 export {
   adminProcedure,
   createCallerFactory,