@wopr-network/platform-core 1.34.0 → 1.35.1

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

@@ -0,0 +1,186 @@
+/**
+ * Tests the profile-filtering + onManualTenantsSkipped logic used inside initFleetUpdater.
+ *
+ * We can't import initFleetUpdater directly because it constructs ImagePoller,
+ * ContainerUpdater, etc. which pull in heavy dependencies that cause hangs.
+ * Instead, we replicate the getUpdatableProfiles closure from initFleetUpdater
+ * and test it in isolation via a RolloutOrchestrator with mock deps.
+ */
+import { describe, expect, it, vi } from "vitest";
+import { RolloutOrchestrator } from "./rollout-orchestrator.js";
+vi.mock("../config/logger.js", () => ({
+    logger: {
+        info: vi.fn(),
+        error: vi.fn(),
+        warn: vi.fn(),
+        debug: vi.fn(),
+    },
+}));
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function makeProfileWithFields(fields) {
+    return {
+        ...fields,
+        image: "ghcr.io/org/img:latest",
+    };
+}
+function makeProfileRepo(profiles) {
+    return {
+        list: vi.fn().mockResolvedValue(profiles),
+        get: vi
+            .fn()
+            .mockImplementation((id) => Promise.resolve(profiles.find((p) => p.id === id) ?? null)),
+        save: vi.fn().mockResolvedValue(undefined),
+        delete: vi.fn().mockResolvedValue(false),
+    };
+}
+function makeConfigRepo(configs = {}) {
+    return {
+        get: vi.fn().mockImplementation((tenantId) => {
+            const cfg = configs[tenantId];
+            return Promise.resolve(cfg ? { tenantId, ...cfg, updatedAt: Date.now() } : null);
+        }),
+        upsert: vi.fn().mockResolvedValue(undefined),
+        listAutoEnabled: vi.fn().mockResolvedValue([]),
+    };
+}
+function makeMockUpdater() {
+    return {
+        updateBot: vi.fn().mockResolvedValue({
+            botId: "",
+            success: true,
+            previousImage: "",
+            newImage: "",
+            previousDigest: null,
+            newDigest: null,
+            rolledBack: false,
+        }),
+    };
+}
+function makeMockSnapshotManager() {
+    return {
+        snapshot: vi.fn(),
+        restore: vi.fn(),
+        delete: vi.fn(),
+    };
+}
+function makeMockStrategy() {
+    return {
+        nextBatch: vi.fn().mockImplementation((remaining) => remaining),
+        pauseDuration: vi.fn().mockReturnValue(0),
+        onBotFailure: vi.fn().mockReturnValue("skip"),
+        maxRetries: vi.fn().mockReturnValue(0),
+        healthCheckTimeout: vi.fn().mockReturnValue(0),
+    };
+}
+/**
+ * Builds the same getUpdatableProfiles closure that initFleetUpdater creates,
+ * so we can test the filtering + callback logic without importing the heavy module.
+ */
+function buildGetUpdatableProfiles(profileRepo, configRepo, onManualTenantsSkipped, imageTag = "v1.2.3") {
+    return async () => {
+        const profiles = await profileRepo.list();
+        const manualPolicyIds = [];
+        const nonManualPolicy = profiles.filter((p) => {
+            if (p.updatePolicy === "manual") {
+                manualPolicyIds.push(p.tenantId);
+                return false;
+            }
+            return true;
+        });
+        if (!configRepo) {
+            if (manualPolicyIds.length > 0 && onManualTenantsSkipped) {
+                onManualTenantsSkipped([...new Set(manualPolicyIds)], imageTag);
+            }
+            return nonManualPolicy;
+        }
+        const configManualIds = [];
+        const results = await Promise.all(nonManualPolicy.map(async (p) => {
+            const tenantCfg = await configRepo.get(p.tenantId);
+            if (tenantCfg && tenantCfg.mode === "manual") {
+                configManualIds.push(p.tenantId);
+                return null;
+            }
+            return p;
+        }));
+        const allManualIds = [...manualPolicyIds, ...configManualIds];
+        if (allManualIds.length > 0 && onManualTenantsSkipped) {
+            onManualTenantsSkipped([...new Set(allManualIds)], imageTag);
+        }
+        return results.filter((p) => p !== null);
+    };
+}
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+describe("initFleetUpdater — onManualTenantsSkipped", () => {
+    it("callback fires with tenant IDs of manual-mode tenants (policy-based)", async () => {
+        const profiles = [
+            makeProfileWithFields({ id: "b1", tenantId: "t-manual", updatePolicy: "manual" }),
+            makeProfileWithFields({ id: "b2", tenantId: "t-auto", updatePolicy: "auto" }),
+        ];
+        const profileRepo = makeProfileRepo(profiles);
+        const onManualTenantsSkipped = vi.fn();
+        const orchestrator = new RolloutOrchestrator({
+            updater: makeMockUpdater(),
+            snapshotManager: makeMockSnapshotManager(),
+            strategy: makeMockStrategy(),
+            getUpdatableProfiles: buildGetUpdatableProfiles(profileRepo, undefined, onManualTenantsSkipped),
+        });
+        await orchestrator.rollout();
+        expect(onManualTenantsSkipped).toHaveBeenCalledWith(["t-manual"], "v1.2.3");
+    });
+    it("callback deduplicates tenant IDs", async () => {
+        const profiles = [
+            makeProfileWithFields({ id: "b1", tenantId: "t-dup", updatePolicy: "manual" }),
+            makeProfileWithFields({ id: "b2", tenantId: "t-dup", updatePolicy: "manual" }),
+            makeProfileWithFields({ id: "b3", tenantId: "t-auto", updatePolicy: "auto" }),
+        ];
+        const profileRepo = makeProfileRepo(profiles);
+        const onManualTenantsSkipped = vi.fn();
+        const orchestrator = new RolloutOrchestrator({
+            updater: makeMockUpdater(),
+            snapshotManager: makeMockSnapshotManager(),
+            strategy: makeMockStrategy(),
+            getUpdatableProfiles: buildGetUpdatableProfiles(profileRepo, undefined, onManualTenantsSkipped),
+        });
+        await orchestrator.rollout();
+        expect(onManualTenantsSkipped).toHaveBeenCalledWith(["t-dup"], "v1.2.3");
+    });
+    it("callback not called when no manual tenants exist", async () => {
+        const profiles = [
+            makeProfileWithFields({ id: "b1", tenantId: "t1", updatePolicy: "auto" }),
+            makeProfileWithFields({ id: "b2", tenantId: "t2", updatePolicy: "auto" }),
+        ];
+        const profileRepo = makeProfileRepo(profiles);
+        const onManualTenantsSkipped = vi.fn();
+        const orchestrator = new RolloutOrchestrator({
+            updater: makeMockUpdater(),
+            snapshotManager: makeMockSnapshotManager(),
+            strategy: makeMockStrategy(),
+            getUpdatableProfiles: buildGetUpdatableProfiles(profileRepo, undefined, onManualTenantsSkipped),
+        });
+        await orchestrator.rollout();
+        expect(onManualTenantsSkipped).not.toHaveBeenCalled();
+    });
+    it("callback fires with config-repo manual tenants when configRepo is provided", async () => {
+        const profiles = [
+            makeProfileWithFields({ id: "b1", tenantId: "t-cfg-manual", updatePolicy: "auto" }),
+            makeProfileWithFields({ id: "b2", tenantId: "t-cfg-auto", updatePolicy: "auto" }),
+        ];
+        const profileRepo = makeProfileRepo(profiles);
+        const configRepo = makeConfigRepo({
+            "t-cfg-manual": { mode: "manual", preferredHourUtc: 3 },
+        });
+        const onManualTenantsSkipped = vi.fn();
+        const orchestrator = new RolloutOrchestrator({
+            updater: makeMockUpdater(),
+            snapshotManager: makeMockSnapshotManager(),
+            strategy: makeMockStrategy(),
+            getUpdatableProfiles: buildGetUpdatableProfiles(profileRepo, configRepo, onManualTenantsSkipped),
+        });
+        await orchestrator.rollout();
+        expect(onManualTenantsSkipped).toHaveBeenCalledWith(["t-cfg-manual"], "v1.2.3");
+    });
+});

package/dist/trpc/admin-fleet-update-router.test.d.ts

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

package/dist/trpc/admin-fleet-update-router.test.js

@@ -0,0 +1,164 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { createAdminFleetUpdateRouter } from "./admin-fleet-update-router.js";
+import { createCallerFactory, router, setTrpcOrgMemberRepo } from "./init.js";
+vi.mock("../config/logger.js", () => ({
+    logger: {
+        info: vi.fn(),
+        error: vi.fn(),
+        warn: vi.fn(),
+        debug: vi.fn(),
+    },
+}));
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function makeMockOrgRepo() {
+    return {
+        listMembers: vi.fn().mockResolvedValue([]),
+        addMember: vi.fn().mockResolvedValue(undefined),
+        updateMemberRole: vi.fn().mockResolvedValue(undefined),
+        removeMember: vi.fn().mockResolvedValue(undefined),
+        findMember: vi.fn().mockResolvedValue(null),
+        countAdminsAndOwners: vi.fn().mockResolvedValue(0),
+        listInvites: vi.fn().mockResolvedValue([]),
+        createInvite: vi.fn().mockResolvedValue(undefined),
+        findInviteById: vi.fn().mockResolvedValue(null),
+        findInviteByToken: vi.fn().mockResolvedValue(null),
+        deleteInvite: vi.fn().mockResolvedValue(undefined),
+        deleteAllMembers: vi.fn().mockResolvedValue(undefined),
+        deleteAllInvites: vi.fn().mockResolvedValue(undefined),
+        listOrgsByUser: vi.fn().mockResolvedValue([]),
+        markInviteAccepted: vi.fn().mockResolvedValue(undefined),
+    };
+}
+function makeOrchestrator(overrides = {}) {
+    return {
+        isRolling: false,
+        rollout: vi.fn().mockResolvedValue({
+            totalBots: 0,
+            succeeded: 0,
+            failed: 0,
+            skipped: 0,
+            aborted: false,
+            alreadyRunning: false,
+            results: [],
+        }),
+        ...overrides,
+    };
+}
+function makeConfigRepo(configs = {}) {
+    return {
+        get: vi.fn().mockImplementation((tenantId) => Promise.resolve(configs[tenantId] ?? null)),
+        upsert: vi.fn().mockResolvedValue(undefined),
+        listAutoEnabled: vi.fn().mockResolvedValue(Object.values(configs)),
+    };
+}
+const adminCtx = {
+    user: { id: "admin-1", roles: ["platform_admin"] },
+    tenantId: undefined,
+};
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+describe("createAdminFleetUpdateRouter", () => {
+    let orchestrator;
+    let configRepo;
+    beforeEach(() => {
+        setTrpcOrgMemberRepo(makeMockOrgRepo());
+        orchestrator = makeOrchestrator();
+        configRepo = makeConfigRepo();
+    });
+    function makeCaller() {
+        const fleetRouter = createAdminFleetUpdateRouter(() => orchestrator, () => configRepo);
+        const appRouter = router({ fleet: fleetRouter });
+        const createCaller = createCallerFactory(appRouter);
+        return createCaller(adminCtx);
+    }
+    describe("rolloutStatus", () => {
+        it("returns isRolling from orchestrator (false)", async () => {
+            const caller = makeCaller();
+            const status = await caller.fleet.rolloutStatus();
+            expect(status).toEqual({ isRolling: false });
+        });
+        it("returns isRolling from orchestrator (true)", async () => {
+            orchestrator = makeOrchestrator({ isRolling: true });
+            const caller = makeCaller();
+            const status = await caller.fleet.rolloutStatus();
+            expect(status).toEqual({ isRolling: true });
+        });
+    });
+    describe("forceRollout", () => {
+        it("calls orchestrator.rollout()", async () => {
+            const caller = makeCaller();
+            const result = await caller.fleet.forceRollout();
+            expect(result).toEqual({ triggered: true });
+            expect(orchestrator.rollout).toHaveBeenCalledOnce();
+        });
+    });
+    describe("listTenantConfigs", () => {
+        it("delegates to repo.listAutoEnabled()", async () => {
+            const configs = [
+                { tenantId: "t1", mode: "auto", preferredHourUtc: 3, updatedAt: Date.now() },
+                { tenantId: "t2", mode: "auto", preferredHourUtc: 12, updatedAt: Date.now() },
+            ];
+            vi.mocked(configRepo.listAutoEnabled).mockResolvedValue(configs);
+            const caller = makeCaller();
+            const result = await caller.fleet.listTenantConfigs();
+            expect(configRepo.listAutoEnabled).toHaveBeenCalledOnce();
+            expect(result).toEqual(configs);
+        });
+    });
+    describe("setTenantConfig", () => {
+        it("preserves existing preferredHourUtc when not provided", async () => {
+            const existing = {
+                tenantId: "t1",
+                mode: "auto",
+                preferredHourUtc: 17,
+                updatedAt: Date.now(),
+            };
+            vi.mocked(configRepo.get).mockResolvedValue(existing);
+            const caller = makeCaller();
+            await caller.fleet.setTenantConfig({ tenantId: "t1", mode: "manual" });
+            expect(configRepo.get).toHaveBeenCalledWith("t1");
+            expect(configRepo.upsert).toHaveBeenCalledWith("t1", {
+                mode: "manual",
+                preferredHourUtc: 17, // preserved from existing
+            });
+        });
+        it("uses provided preferredHourUtc when given", async () => {
+            const existing = {
+                tenantId: "t1",
+                mode: "auto",
+                preferredHourUtc: 17,
+                updatedAt: Date.now(),
+            };
+            vi.mocked(configRepo.get).mockResolvedValue(existing);
+            const caller = makeCaller();
+            await caller.fleet.setTenantConfig({
+                tenantId: "t1",
+                mode: "auto",
+                preferredHourUtc: 9,
+            });
+            expect(configRepo.upsert).toHaveBeenCalledWith("t1", {
+                mode: "auto",
+                preferredHourUtc: 9,
+            });
+        });
+        it("defaults to 3 when no existing config and preferredHourUtc not provided", async () => {
+            vi.mocked(configRepo.get).mockResolvedValue(null);
+            const caller = makeCaller();
+            await caller.fleet.setTenantConfig({ tenantId: "t-new", mode: "auto" });
+            expect(configRepo.upsert).toHaveBeenCalledWith("t-new", {
+                mode: "auto",
+                preferredHourUtc: 3, // default
+            });
+        });
+    });
+    it("rejects non-admin users", async () => {
+        const fleetRouter = createAdminFleetUpdateRouter(() => orchestrator, () => configRepo);
+        const appRouter = router({ fleet: fleetRouter });
+        const createCaller = createCallerFactory(appRouter);
+        const caller = createCaller({ user: { id: "u1", roles: ["user"] }, tenantId: undefined });
+        await expect(caller.fleet.rolloutStatus()).rejects.toThrow("Platform admin role required");
+    });
+});

package/drizzle/migrations/0012_seed_popular_tokens.sql

@@ -0,0 +1,12 @@
+-- Verified Base mainnet contract addresses (source: basescan.org)
+INSERT INTO "payment_methods" ("id", "type", "token", "chain", "contract_address", "decimals", "display_name", "display_order", "confirmations") VALUES
+  ('WETH:base', 'erc20', 'WETH', 'base', '0x4200000000000000000000000000000000000006', 18, 'Wrapped ETH on Base', 4, 1),
+  ('cbBTC:base', 'erc20', 'cbBTC', 'base', '0xcbB7C0000aB88B473b1f5aFd9ef808440eed33Bf', 8, 'Coinbase BTC on Base', 5, 1),
+  ('AERO:base', 'erc20', 'AERO', 'base', '0x940181a94A35A4569E4529A3CDfB74e38FD98631', 18, 'Aerodrome on Base', 6, 1),
+  ('LINK:base', 'erc20', 'LINK', 'base', '0x88Fb150BDc53A65fe94Dea0c9BA0a6dAf8C6e196', 18, 'Chainlink on Base', 7, 1),
+  ('UNI:base', 'erc20', 'UNI', 'base', '0xc3De830EA07524a0761646a6a4e4be0e114a3C83', 18, 'Uniswap on Base', 8, 1),
+  ('LTC:litecoin', 'native', 'LTC', 'litecoin', NULL, 8, 'Litecoin', 9, 6),
+  ('DOGE:dogecoin', 'native', 'DOGE', 'dogecoin', NULL, 8, 'Dogecoin', 10, 6)
+ON CONFLICT ("id") DO NOTHING;
+-- NOTE: PEPE, SHIB, RENDER not seeded — unverified Base contract addresses.
+-- Add via admin panel after verifying contracts on basescan.org.

package/package.json

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

package/src/billing/crypto/btc/address-gen.ts

@@ -55,6 +55,55 @@ export function deriveTreasury(xpub: string, network: UtxoNetwork = "mainnet", c
   return bech32.encode(prefix, [0, ...words]);
 }
 
+/** P2PKH version bytes for Base58Check encoding (chains without bech32). */
+const P2PKH_VERSION: Record<string, Record<string, number>> = {
+  dogecoin: { mainnet: 0x1e, testnet: 0x71 },
+};
+
+const BASE58_ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+function base58encode(data: Uint8Array): string {
+  let num = 0n;
+  for (const byte of data) num = num * 256n + BigInt(byte);
+  let encoded = "";
+  while (num > 0n) {
+    encoded = BASE58_ALPHABET[Number(num % 58n)] + encoded;
+    num = num / 58n;
+  }
+  for (const byte of data) {
+    if (byte !== 0) break;
+    encoded = "1" + encoded;
+  }
+  return encoded;
+}
+
+/**
+ * Derive a P2PKH (Base58Check) address for chains without bech32 (e.g., DOGE → D...).
+ */
+export function deriveP2pkhAddress(
+  xpub: string,
+  index: number,
+  chain: string,
+  network: "mainnet" | "testnet" = "mainnet",
+): string {
+  if (!Number.isInteger(index) || index < 0) throw new Error(`Invalid derivation index: ${index}`);
+  const version = P2PKH_VERSION[chain]?.[network];
+  if (version === undefined) throw new Error(`No P2PKH version for chain=${chain} network=${network}`);
+
+  const master = HDKey.fromExtendedKey(xpub);
+  const child = master.deriveChild(0).deriveChild(index);
+  if (!child.publicKey) throw new Error("Failed to derive public key");
+
+  const hash160 = ripemd160(sha256(child.publicKey));
+  const payload = new Uint8Array(21);
+  payload[0] = version;
+  payload.set(hash160, 1);
+  const checksum = sha256(sha256(payload));
+  const full = new Uint8Array(25);
+  full.set(payload);
+  full.set(checksum.slice(0, 4), 21);
+  return base58encode(full);
+}
+
 /** @deprecated Use `deriveAddress` instead. */
 export const deriveBtcAddress = deriveAddress;
 

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

@@ -36,17 +36,17 @@ export interface ChainlinkOracleOpts {
  */
 export class ChainlinkOracle implements IPriceOracle {
   private readonly rpc: RpcCall;
-  private readonly feeds: Record<PriceAsset, `0x${string}`>;
+  private readonly feeds: Map<string, `0x${string}`>;
   private readonly maxStalenessMs: number;
 
   constructor(opts: ChainlinkOracleOpts) {
     this.rpc = opts.rpcCall;
-    this.feeds = { ...FEED_ADDRESSES, ...opts.feedAddresses };
+    this.feeds = new Map(Object.entries({ ...FEED_ADDRESSES, ...opts.feedAddresses })) as Map<string, `0x${string}`>;
     this.maxStalenessMs = opts.maxStalenessMs ?? DEFAULT_MAX_STALENESS_MS;
   }
 
   async getPrice(asset: PriceAsset): Promise<PriceResult> {
-    const feedAddress = this.feeds[asset];
+    const feedAddress = this.feeds.get(asset);
     if (!feedAddress) throw new Error(`No price feed for asset: ${asset}`);
 
     const result = (await this.rpc("eth_call", [{ to: feedAddress, data: LATEST_ROUND_DATA }, "latest"])) as string;

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

@@ -1,5 +1,5 @@
 /** Assets with Chainlink price feeds. */
-export type PriceAsset = "ETH" | "BTC";
+export type PriceAsset = string;
 
 /** Result from a price oracle query. */
 export interface PriceResult {

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

@@ -1,4 +1,5 @@
 import { Credit } from "../../credits/credit.js";
+import { deriveAddress, deriveP2pkhAddress } from "./btc/address-gen.js";
 import type { ICryptoChargeRepository } from "./charge-store.js";
 import { deriveDepositAddress } from "./evm/address-gen.js";
 import { centsToNative } from "./oracle/convert.js";
@@ -50,11 +51,11 @@ export async function createUnifiedCheckout(
   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.type === "native" && method.chain === "base") {
+    return handleNativeEvm(deps, method, opts.tenant, amountUsdCents, opts.amountUsd);
   }
-  if (method.token === "BTC") {
-    return handleNativeBtc(deps, method, opts.tenant, amountUsdCents, opts.amountUsd);
+  if (method.type === "native") {
+    return handleNativeUtxo(deps, method, opts.tenant, amountUsdCents, opts.amountUsd);
   }
 
   throw new Error(`Unsupported payment method type: ${method.type}/${method.token}`);
@@ -79,7 +80,7 @@ async function handleErc20(
   };
 }
 
-async function handleNativeEth(
+async function handleNativeEvm(
   deps: UnifiedCheckoutDeps,
   method: PaymentMethodRecord,
   tenant: string,
@@ -105,44 +106,57 @@ async function handleNativeEth(
   };
 }
 
-async function handleNativeBtc(
+/**
+ * Handle native UTXO coins (BTC, LTC, DOGE, BCH, etc.).
+ * Uses the xpub from the payment method record (DB-driven).
+ * Derives bech32 addresses for BTC/LTC, Base58 P2PKH for DOGE.
+ */
+async function handleNativeUtxo(
   deps: UnifiedCheckoutDeps,
-  _method: PaymentMethodRecord,
+  method: PaymentMethodRecord,
   tenant: string,
   amountUsdCents: number,
   amountUsd: number,
 ): Promise<UnifiedCheckoutResult> {
-  const { priceCents } = await deps.oracle.getPrice("BTC");
-  const expectedSats = centsToNative(amountUsdCents, priceCents, 8);
+  const xpub = method.xpub ?? deps.btcXpub;
+  if (!xpub) throw new Error(`${method.token} payments not configured (no xpub)`);
 
-  // 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 { priceCents } = await deps.oracle.getPrice(method.token);
+  const rawAmount = centsToNative(amountUsdCents, priceCents, method.decimals);
 
   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}`;
+
+    // Derive address by chain type
+    let depositAddress: string;
+    if (method.chain === "dogecoin") {
+      depositAddress = deriveP2pkhAddress(xpub, derivationIndex, "dogecoin");
+    } else {
+      depositAddress = deriveAddress(xpub, derivationIndex, "mainnet", method.chain as "bitcoin" | "litecoin");
+    }
+
+    const referenceId = `${method.token.toLowerCase()}:${depositAddress}`;
 
     try {
       await deps.chargeStore.createStablecoinCharge({
         referenceId,
         tenantId: tenant,
         amountUsdCents,
-        chain: "bitcoin",
-        token: "BTC",
+        chain: method.chain,
+        token: method.token,
         depositAddress,
         derivationIndex,
       });
 
-      const btcAmount = Number(expectedSats) / 100_000_000;
+      const divisor = 10 ** method.decimals;
+      const displayAmt = (Number(rawAmount) / divisor).toFixed(method.decimals);
       return {
         depositAddress,
-        displayAmount: `${btcAmount.toFixed(8)} BTC`,
+        displayAmount: `${displayAmt} ${method.token}`,
         amountUsd,
-        token: "BTC",
-        chain: "bitcoin",
+        token: method.token,
+        chain: method.chain,
         referenceId,
         priceCents,
       };