@wopr-network/platform-core 1.58.1 → 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/dist/db/schema/index.d.ts

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

package/dist/db/schema/index.js

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