@wopr-network/platform-core 1.25.0 → 1.27.0

package/dist/fleet/__tests__/tenant-update-config-repository.test.js

@@ -0,0 +1,55 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, it } from "vitest";
+import { beginTestTransaction, createTestDb, endTestTransaction, rollbackTestTransaction } from "../../test/db.js";
+import { DrizzleTenantUpdateConfigRepository } from "../drizzle-tenant-update-config-repository.js";
+describe("DrizzleTenantUpdateConfigRepository", () => {
+    let db;
+    let pool;
+    let repo;
+    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/dist/fleet/drizzle-tenant-update-config-repository.d.ts

@@ -0,0 +1,10 @@
+import type { DrizzleDb } from "../db/index.js";
+import type { ITenantUpdateConfigRepository, TenantUpdateConfig } from "./tenant-update-config-repository.js";
+/** Drizzle-backed implementation of ITenantUpdateConfigRepository. */
+export declare class DrizzleTenantUpdateConfigRepository implements ITenantUpdateConfigRepository {
+    private readonly db;
+    constructor(db: DrizzleDb);
+    get(tenantId: string): Promise<TenantUpdateConfig | null>;
+    upsert(tenantId: string, config: Omit<TenantUpdateConfig, "tenantId" | "updatedAt">): Promise<void>;
+    listAutoEnabled(): Promise<TenantUpdateConfig[]>;
+}

package/dist/fleet/drizzle-tenant-update-config-repository.js

@@ -0,0 +1,44 @@
+import { eq } from "drizzle-orm";
+import { tenantUpdateConfigs } from "../db/schema/index.js";
+/** Drizzle-backed implementation of ITenantUpdateConfigRepository. */
+export class DrizzleTenantUpdateConfigRepository {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async get(tenantId) {
+        const rows = await this.db.select().from(tenantUpdateConfigs).where(eq(tenantUpdateConfigs.tenantId, tenantId));
+        return rows[0] ? toConfig(rows[0]) : null;
+    }
+    async upsert(tenantId, config) {
+        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() {
+        const rows = await this.db.select().from(tenantUpdateConfigs).where(eq(tenantUpdateConfigs.mode, "auto"));
+        return rows.map(toConfig);
+    }
+}
+function toConfig(row) {
+    return {
+        tenantId: row.tenantId,
+        mode: row.mode,
+        preferredHourUtc: row.preferredHourUtc,
+        updatedAt: row.updatedAt,
+    };
+}

package/dist/fleet/fleet-event-emitter.d.ts

@@ -1,5 +1,5 @@
 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" | "node.registered" | "node.draining" | "node.drained" | "node.deprovisioned" | "node.heartbeat_lost" | "node.returned";
 export type FleetEventType = BotEventType | NodeEventType;
 export interface BotFleetEvent {

package/dist/fleet/index.d.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/dist/fleet/index.js

@@ -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/dist/fleet/init-fleet-updater.d.ts

@@ -12,11 +12,13 @@
  */
 import type Docker from "dockerode";
 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 { 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";
 export interface FleetUpdaterConfig {
@@ -34,6 +36,10 @@ export interface FleetUpdaterConfig {
     }) => 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 {
     poller: ImagePoller;

package/dist/fleet/init-fleet-updater.js

@@ -29,7 +29,7 @@ import { VolumeSnapshotManager } from "./volume-snapshot-manager.js";
  * @param config - Optional pipeline configuration
  */
 export function initFleetUpdater(docker, fleet, profileStore, profileRepo, config = {}) {
-    const { strategy: strategyType = "rolling-wave", strategyOptions, snapshotDir = "/data/fleet/snapshots", onBotUpdated, onRolloutComplete, } = config;
+    const { strategy: strategyType = "rolling-wave", strategyOptions, snapshotDir = "/data/fleet/snapshots", onBotUpdated, onRolloutComplete, configRepo, eventEmitter, } = config;
     const poller = new ImagePoller(docker, profileStore);
     const updater = new ContainerUpdater(docker, profileStore, fleet, poller);
     const snapshotManager = new VolumeSnapshotManager(docker, snapshotDir);
@@ -40,10 +40,35 @@ export function initFleetUpdater(docker, fleet, profileStore, profileRepo, confi
         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.
     // Any digest change triggers a fleet-wide rollout because the managed image

package/dist/fleet/services.d.ts

@@ -42,6 +42,7 @@ import { OrphanCleaner } from "./orphan-cleaner.js";
 import { RecoveryOrchestrator } from "./recovery-orchestrator.js";
 import type { IRecoveryRepository } from "./recovery-repository.js";
 import type { IRegistrationTokenRepository } from "./registration-token-store.js";
+import type { ITenantUpdateConfigRepository } from "./tenant-update-config-repository.js";
 import type { IVpsRepository } from "./vps-repository.js";
 export declare function getPool(): Pool;
 export declare function getDb(): DrizzleDb;
@@ -71,6 +72,7 @@ export declare function getMigrationOrchestrator(): MigrationOrchestrator;
 export declare function getNodeDrainer(): NodeDrainer;
 export declare function getFleetEventEmitter(): FleetEventEmitter;
 export declare function getFleetEventRepo(): IFleetEventRepository;
+export declare function getTenantUpdateConfigRepo(): ITenantUpdateConfigRepository;
 export declare function getHeartbeatWatchdog(): HeartbeatWatchdog;
 export declare function getInferenceWatchdog(): InferenceWatchdog;
 export declare function getDOClient(): DOClient;

package/dist/fleet/services.js

@@ -37,6 +37,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 { DrizzleGpuAllocationRepository } from "./gpu-allocation-repository.js";
 import { DrizzleGpuConfigurationRepository } from "./gpu-configuration-repository.js";
@@ -95,6 +96,8 @@ let _inferenceWatchdog = null;
 let _fleetEventEmitter = null;
 // Fleet event repository
 let _fleetEventRepo = null;
+// Tenant update config
+let _tenantUpdateConfigRepo = null;
 // Infrastructure
 let _doClient = null;
 let _nodeProvider = null;
@@ -317,6 +320,12 @@ export function getFleetEventRepo() {
     }
     return _fleetEventRepo;
 }
+export function getTenantUpdateConfigRepo() {
+    if (!_tenantUpdateConfigRepo) {
+        _tenantUpdateConfigRepo = new DrizzleTenantUpdateConfigRepository(getDb());
+    }
+    return _tenantUpdateConfigRepo;
+}
 // ---------------------------------------------------------------------------
 // HeartbeatWatchdog
 // ---------------------------------------------------------------------------
@@ -694,6 +703,7 @@ export function _resetForTest() {
     _inferenceWatchdog = null;
     _fleetEventRepo = null;
     _fleetEventEmitter = null;
+    _tenantUpdateConfigRepo = null;
     _doClient = null;
     _nodeProvider = null;
     _nodeProvisioner = null;

package/dist/fleet/tenant-update-config-repository.d.ts

@@ -0,0 +1,11 @@
+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/dist/fleet/tenant-update-config-repository.js

@@ -0,0 +1 @@
+export {};

package/dist/trpc/fleet-update-config-router.d.ts

@@ -0,0 +1,24 @@
+import type { ITenantUpdateConfigRepository } from "../fleet/tenant-update-config-repository.js";
+export declare function createFleetUpdateConfigRouter(configRepo: ITenantUpdateConfigRepository): import("@trpc/server").TRPCBuiltRouter<{
+    ctx: import("./init.js").TRPCContext;
+    meta: object;
+    errorShape: import("@trpc/server").TRPCDefaultErrorShape;
+    transformer: false;
+}, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
+    getUpdateConfig: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            tenantId: string;
+        };
+        output: import("../fleet/tenant-update-config-repository.js").TenantUpdateConfig | null;
+        meta: object;
+    }>;
+    setUpdateConfig: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            tenantId: string;
+            mode: "manual" | "auto";
+            preferredHourUtc?: number | undefined;
+        };
+        output: void;
+        meta: object;
+    }>;
+}>>;

package/dist/trpc/fleet-update-config-router.js

@@ -0,0 +1,26 @@
+import { z } from "zod";
+import { logger } from "../config/logger.js";
+import { protectedProcedure, router } from "./init.js";
+export function createFleetUpdateConfigRouter(configRepo) {
+    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/dist/trpc/index.d.ts

@@ -1 +1,2 @@
+export { createFleetUpdateConfigRouter } from "./fleet-update-config-router.js";
 export { adminProcedure, createCallerFactory, orgAdminProcedure, orgMemberProcedure, protectedProcedure, publicProcedure, router, setTrpcOrgMemberRepo, type TRPCContext, tenantProcedure, } from "./init.js";

package/dist/trpc/index.js

@@ -1 +1,2 @@
+export { createFleetUpdateConfigRouter } from "./fleet-update-config-router.js";
 export { adminProcedure, createCallerFactory, orgAdminProcedure, orgMemberProcedure, protectedProcedure, publicProcedure, router, setTrpcOrgMemberRepo, tenantProcedure, } from "./init.js";

package/drizzle/migrations/0008_payment_methods.sql

@@ -0,0 +1,22 @@
+CREATE TABLE IF NOT EXISTS "payment_methods" (
+  "id" text PRIMARY KEY NOT NULL,
+  "type" text NOT NULL,
+  "token" text NOT NULL,
+  "chain" text NOT NULL,
+  "contract_address" text,
+  "decimals" integer NOT NULL,
+  "display_name" text NOT NULL,
+  "enabled" boolean NOT NULL DEFAULT true,
+  "display_order" integer NOT NULL DEFAULT 0,
+  "rpc_url" text,
+  "confirmations" integer NOT NULL DEFAULT 1,
+  "created_at" text DEFAULT (now()) NOT NULL
+);
+--> statement-breakpoint
+INSERT INTO "payment_methods" ("id", "type", "token", "chain", "contract_address", "decimals", "display_name", "display_order", "confirmations") VALUES
+  ('USDC:base', 'erc20', 'USDC', 'base', '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913', 6, 'USDC on Base', 0, 1),
+  ('USDT:base', 'erc20', 'USDT', 'base', '0xfde4C96c8593536E31F229EA8f37b2ADa2699bb2', 6, 'USDT on Base', 1, 1),
+  ('DAI:base', 'erc20', 'DAI', 'base', '0x50c5725949A6F0c72E6C4a641F24049A917DB0Cb', 18, 'DAI on Base', 2, 1),
+  ('ETH:base', 'native', 'ETH', 'base', NULL, 18, 'ETH on Base', 3, 1),
+  ('BTC:mainnet', 'native', 'BTC', 'bitcoin', NULL, 8, 'Bitcoin', 10, 3)
+ON CONFLICT ("id") DO NOTHING;

package/drizzle/migrations/0009_tenant_update_configs.sql

@@ -0,0 +1,6 @@
+CREATE TABLE IF NOT EXISTS "tenant_update_configs" (
+  "tenant_id" text PRIMARY KEY NOT NULL,
+  "mode" text DEFAULT 'manual' NOT NULL,
+  "preferred_hour_utc" integer DEFAULT 3 NOT NULL,
+  "updated_at" bigint NOT NULL
+);

package/drizzle/migrations/meta/_journal.json

@@ -57,6 +57,20 @@
       "when": 1742227200000,
       "tag": "0007_watcher_cursors",
       "breakpoints": true
+    },
+    {
+      "idx": 8,
+      "version": "7",
+      "when": 1742313600000,
+      "tag": "0008_payment_methods",
+      "breakpoints": true
+    },
+    {
+      "idx": 9,
+      "version": "7",
+      "when": 1742400000000,
+      "tag": "0009_tenant_update_configs",
+      "breakpoints": true
     }
   ]
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wopr-network/platform-core",
-  "version": "1.25.0",
+  "version": "1.27.0",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/billing/crypto/index.ts

@@ -8,6 +8,8 @@ export type { IWatcherCursorStore } from "./cursor-store.js";
 export { DrizzleWatcherCursorStore } from "./cursor-store.js";
 export * from "./evm/index.js";
 export * from "./oracle/index.js";
+export type { IPaymentMethodStore, PaymentMethodRecord } from "./payment-method-store.js";
+export { DrizzlePaymentMethodStore } from "./payment-method-store.js";
 export type {
   CryptoBillingConfig,
   CryptoCheckoutOpts,
@@ -16,5 +18,7 @@ export type {
   CryptoWebhookResult,
 } from "./types.js";
 export { mapBtcPayEventToStatus } from "./types.js";
+export type { UnifiedCheckoutDeps, UnifiedCheckoutResult } from "./unified-checkout.js";
+export { createUnifiedCheckout, MIN_CHECKOUT_USD } from "./unified-checkout.js";
 export type { CryptoWebhookDeps } from "./webhook.js";
 export { handleCryptoWebhook, verifyCryptoWebhookSignature } from "./webhook.js";

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

@@ -0,0 +1,117 @@
+import { and, eq } from "drizzle-orm";
+import type { PlatformDb } from "../../db/index.js";
+import { paymentMethods } from "../../db/schema/crypto.js";
+
+export interface PaymentMethodRecord {
+  id: string;
+  type: string;
+  token: string;
+  chain: string;
+  contractAddress: string | null;
+  decimals: number;
+  displayName: string;
+  enabled: boolean;
+  displayOrder: number;
+  rpcUrl: string | null;
+  confirmations: number;
+}
+
+export interface IPaymentMethodStore {
+  /** List all enabled payment methods, ordered by displayOrder. */
+  listEnabled(): Promise<PaymentMethodRecord[]>;
+  /** List all payment methods (including disabled). */
+  listAll(): Promise<PaymentMethodRecord[]>;
+  /** Get a specific payment method by id. */
+  getById(id: string): Promise<PaymentMethodRecord | null>;
+  /** Get enabled methods by type (stablecoin, eth, btc). */
+  listByType(type: string): Promise<PaymentMethodRecord[]>;
+  /** Upsert a payment method (admin). */
+  upsert(method: PaymentMethodRecord): Promise<void>;
+  /** Enable or disable a payment method (admin). */
+  setEnabled(id: string, enabled: boolean): Promise<void>;
+}
+
+export class DrizzlePaymentMethodStore implements IPaymentMethodStore {
+  constructor(private readonly db: PlatformDb) {}
+
+  async listEnabled(): Promise<PaymentMethodRecord[]> {
+    const rows = await this.db
+      .select()
+      .from(paymentMethods)
+      .where(eq(paymentMethods.enabled, true))
+      .orderBy(paymentMethods.displayOrder);
+    return rows.map(toRecord);
+  }
+
+  async listAll(): Promise<PaymentMethodRecord[]> {
+    const rows = await this.db.select().from(paymentMethods).orderBy(paymentMethods.displayOrder);
+    return rows.map(toRecord);
+  }
+
+  async getById(id: string): Promise<PaymentMethodRecord | null> {
+    const row = (await this.db.select().from(paymentMethods).where(eq(paymentMethods.id, id)))[0];
+    return row ? toRecord(row) : null;
+  }
+
+  async listByType(type: string): Promise<PaymentMethodRecord[]> {
+    const rows = await this.db
+      .select()
+      .from(paymentMethods)
+      .where(and(eq(paymentMethods.type, type), eq(paymentMethods.enabled, true)))
+      .orderBy(paymentMethods.displayOrder);
+    return rows.map(toRecord);
+  }
+
+  async upsert(method: PaymentMethodRecord): Promise<void> {
+    await this.db
+      .insert(paymentMethods)
+      .values({
+        id: method.id,
+        type: method.type,
+        token: method.token,
+        chain: method.chain,
+        contractAddress: method.contractAddress,
+        decimals: method.decimals,
+        displayName: method.displayName,
+        enabled: method.enabled,
+        displayOrder: method.displayOrder,
+        rpcUrl: method.rpcUrl,
+        confirmations: method.confirmations,
+      })
+      .onConflictDoUpdate({
+        target: paymentMethods.id,
+        set: {
+          type: method.type,
+          token: method.token,
+          chain: method.chain,
+          contractAddress: method.contractAddress,
+          decimals: method.decimals,
+          displayName: method.displayName,
+          enabled: method.enabled,
+          displayOrder: method.displayOrder,
+          rpcUrl: method.rpcUrl,
+          confirmations: method.confirmations,
+        },
+      });
+  }
+
+  async setEnabled(id: string, enabled: boolean): Promise<void> {
+    await this.db.update(paymentMethods).set({ enabled }).where(eq(paymentMethods.id, id));
+  }
+}
+
+function toRecord(row: typeof paymentMethods.$inferSelect): PaymentMethodRecord {
+  return {
+    id: row.id,
+    type: row.type,
+    token: row.token,
+    chain: row.chain,
+    contractAddress: row.contractAddress,
+    decimals: row.decimals,
+    displayName: row.displayName,
+    enabled: row.enabled,
+    displayOrder: row.displayOrder,
+    rpcUrl: row.rpcUrl,
+    confirmations: row.confirmations,
+  };
+}