@wopr-network/platform-core 1.59.0 → 1.60.0

package/dist/billing/crypto/__tests__/key-server.test.js

@@ -12,6 +12,7 @@ function createMockDb() {
         decimals: 8,
         addressType: "bech32",
         encodingParams: '{"hrp":"bc"}',
+        watcherType: "utxo",
         confirmations: 6,
     };
     const db = {
@@ -180,6 +181,7 @@ describe("key-server routes", () => {
             decimals: 18,
             addressType: "evm",
             encodingParams: "{}",
+            watcherType: "evm",
             confirmations: 1,
         };
         const db = {
@@ -239,6 +241,7 @@ describe("key-server routes", () => {
             decimals: 18,
             addressType: "evm",
             encodingParams: "{}",
+            watcherType: "evm",
             confirmations: 1,
         };
         const db = {

package/dist/billing/crypto/key-server.js

@@ -296,6 +296,7 @@ export function createKeyServerApp(deps) {
             xpub: body.xpub,
             addressType: body.address_type ?? "evm",
             encodingParams: JSON.stringify(body.encoding_params ?? {}),
+            watcherType: body.watcher_type ?? "evm",
             confirmations: body.confirmations ?? 6,
         });
         return c.json({ id: body.id, path: `m/44'/${body.coin_type}'/${body.account_index}'` }, 201);

package/dist/billing/crypto/oracle/coingecko.js

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

package/dist/billing/crypto/payment-method-store.d.ts

@@ -15,6 +15,7 @@ export interface PaymentMethodRecord {
     xpub: string | null;
     addressType: string;
     encodingParams: string;
+    watcherType: string;
     confirmations: number;
 }
 export interface IPaymentMethodStore {

package/dist/billing/crypto/payment-method-store.js

@@ -48,6 +48,7 @@ export class DrizzlePaymentMethodStore {
             xpub: method.xpub,
             addressType: method.addressType,
             encodingParams: method.encodingParams,
+            watcherType: method.watcherType,
             confirmations: method.confirmations,
         })
             .onConflictDoUpdate({
@@ -67,6 +68,7 @@ export class DrizzlePaymentMethodStore {
                 xpub: method.xpub,
                 addressType: method.addressType,
                 encodingParams: method.encodingParams,
+                watcherType: method.watcherType,
                 confirmations: method.confirmations,
             },
         });
@@ -105,6 +107,7 @@ function toRecord(row) {
         xpub: row.xpub,
         addressType: row.addressType,
         encodingParams: row.encodingParams,
+        watcherType: row.watcherType,
         confirmations: row.confirmations,
     };
 }

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

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

package/dist/billing/crypto/tron/__tests__/address-convert.test.js

@@ -0,0 +1,55 @@
+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/dist/billing/crypto/tron/address-convert.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Convert a Tron T... address to 0x hex (20 bytes, no 0x41 prefix).
+ * For feeding addresses to the EVM watcher JSON-RPC filters.
+ */
+export declare function tronToHex(tronAddr: string): string;
+/**
+ * Convert a 0x hex address (20 bytes) back to Tron T... Base58Check.
+ * For converting watcher event addresses back to DB format.
+ */
+export declare function hexToTron(hexAddr: string): string;
+/**
+ * Check if an address is a Tron T... address.
+ */
+export declare function isTronAddress(addr: string): boolean;

package/dist/billing/crypto/tron/address-convert.js

@@ -0,0 +1,83 @@
+/**
+ * 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) {
+    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) {
+    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) {
+    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) {
+    return addr.startsWith("T") && addr.length >= 33 && addr.length <= 35;
+}

package/dist/billing/crypto/watcher-service.js

@@ -16,6 +16,7 @@ import { cryptoCharges, webhookDeliveries } from "../../db/schema/crypto.js";
 import { BtcWatcher, createBitcoindRpc } from "./btc/watcher.js";
 import { EthWatcher } from "./evm/eth-watcher.js";
 import { createRpcCaller, EvmWatcher } from "./evm/watcher.js";
+import { hexToTron, isTronAddress, tronToHex } from "./tron/address-convert.js";
 const MAX_DELIVERY_ATTEMPTS = 10;
 const BACKOFF_BASE_MS = 5_000;
 // --- SSRF validation ---
@@ -181,9 +182,10 @@ export async function startWatchers(opts) {
     const serviceKey = opts.serviceKey;
     const timers = [];
     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) {
         if (!method.rpcUrl)
@@ -272,6 +274,12 @@ export async function startWatchers(opts) {
     const nativeEvmMethods = evmMethods.filter((m) => m.type === "native");
     const erc20Methods = evmMethods.filter((m) => m.type === "erc20" && m.contractAddress);
     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) => method.addressType === "p2pkh";
+    const toWatcherAddr = (addr, method) => needsAddrConvert(method) && isTronAddress(addr) ? tronToHex(addr) : addr;
+    const fromWatcherAddr = (addr, method) => needsAddrConvert(method) ? hexToTron(addr) : addr;
     for (const method of nativeEvmMethods) {
         if (!method.rpcUrl)
             continue;
@@ -289,19 +297,20 @@ export async function startWatchers(opts) {
             rpcCall,
             oracle,
             fromBlock: backfillStart,
-            watchedAddresses: chainAddresses,
+            watchedAddresses: chainAddresses.map((a) => toWatcherAddr(a, method)),
             cursorStore,
             confirmations: method.confirmations,
             onPayment: async (event) => {
+                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,
                     confirmationsRequired: event.confirmationsRequired,
                 });
-                await handlePayment(db, chargeStore, event.to, event.valueWei, {
+                await handlePayment(db, chargeStore, dbAddr, event.valueWei, {
                     txHash: event.txHash,
                     confirmations: event.confirmations,
                     confirmationsRequired: event.confirmationsRequired,
@@ -321,7 +330,7 @@ export async function startWatchers(opts) {
                 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) {
@@ -346,21 +355,22 @@ export async function startWatchers(opts) {
             token: method.token,
             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) => {
+                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,
                 });
-                await handlePayment(db, chargeStore, event.to, event.rawAmount, {
+                await handlePayment(db, chargeStore, dbAddr, event.rawAmount, {
                     txHash: event.txHash,
                     confirmations: event.confirmations,
                     confirmationsRequired: event.confirmationsRequired,
@@ -378,7 +388,7 @@ export async function startWatchers(opts) {
             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) {

package/dist/db/schema/crypto.d.ts

@@ -699,6 +699,23 @@ export declare const paymentMethods: import("drizzle-orm/pg-core").PgTableWithCo
             identity: undefined;
             generated: undefined;
         }, {}, {}>;
+        watcherType: import("drizzle-orm/pg-core").PgColumn<{
+            name: "watcher_type";
+            tableName: "payment_methods";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
         confirmations: import("drizzle-orm/pg-core").PgColumn<{
             name: "confirmations";
             tableName: "payment_methods";

package/dist/db/schema/crypto.js

@@ -77,6 +77,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/drizzle/migrations/0021_watcher_type_column.sql

@@ -0,0 +1,3 @@
+ALTER TABLE "payment_methods" ADD COLUMN "watcher_type" text DEFAULT 'evm' NOT NULL;
+--> statement-breakpoint
+UPDATE "payment_methods" SET "watcher_type" = 'utxo' WHERE "chain" IN ('bitcoin', 'litecoin', 'dogecoin');

package/package.json

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

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())`),