@wopr-network/platform-core 1.63.1 → 1.64.0

package/src/billing/crypto/key-server.ts

@@ -317,12 +317,14 @@ export function createKeyServerApp(deps: KeyServerDeps): Hono {
       decimals: number;
       xpub: string;
       rpc_url: string;
+      rpc_headers?: Record<string, string>;
       confirmations?: number;
       display_name?: string;
       oracle_address?: string;
       address_type?: string;
       encoding_params?: Record<string, string>;
       watcher_type?: string;
+      oracle_asset_id?: string;
       icon_url?: string;
       display_order?: number;
     }>();
@@ -331,24 +333,6 @@ export function createKeyServerApp(deps: KeyServerDeps): Hono {
       return c.json({ error: "id, xpub, and token are required" }, 400);
     }
 
-    // Record the path allocation (idempotent — ignore if already exists)
-    const inserted = (await deps.db
-      .insert(pathAllocations)
-      .values({
-        coinType: body.coin_type,
-        accountIndex: body.account_index,
-        chainId: body.id,
-        xpub: body.xpub,
-      })
-      .onConflictDoNothing()) as { rowCount: number };
-
-    if (inserted.rowCount === 0) {
-      return c.json(
-        { error: "Path allocation already exists", path: `m/44'/${body.coin_type}'/${body.account_index}'` },
-        409,
-      );
-    }
-
     // Validate encoding_params match address_type requirements
     const addrType = body.address_type ?? "evm";
     const encParams = body.encoding_params ?? {};
@@ -359,7 +343,7 @@ export function createKeyServerApp(deps: KeyServerDeps): Hono {
       return c.json({ error: "p2pkh address_type requires encoding_params.version" }, 400);
     }
 
-    // Upsert the payment method
+    // Upsert payment method FIRST (path_allocations has FK to payment_methods.id)
     await deps.methodStore.upsert({
       id: body.id,
       type: body.type ?? "native",
@@ -372,14 +356,37 @@ export function createKeyServerApp(deps: KeyServerDeps): Hono {
       displayOrder: body.display_order ?? 0,
       iconUrl: body.icon_url ?? null,
       rpcUrl: body.rpc_url,
+      rpcHeaders: JSON.stringify(body.rpc_headers ?? {}),
       oracleAddress: body.oracle_address ?? null,
       xpub: body.xpub,
       addressType: body.address_type ?? "evm",
       encodingParams: JSON.stringify(body.encoding_params ?? {}),
       watcherType: body.watcher_type ?? "evm",
+      oracleAssetId: body.oracle_asset_id ?? null,
       confirmations: body.confirmations ?? 6,
     });
 
+    // Record the path allocation (idempotent — ignore if already exists)
+    const inserted = (await deps.db
+      .insert(pathAllocations)
+      .values({
+        coinType: body.coin_type,
+        accountIndex: body.account_index,
+        chainId: body.id,
+        xpub: body.xpub,
+      })
+      .onConflictDoNothing()) as { rowCount: number };
+
+    if (inserted.rowCount === 0) {
+      return c.json(
+        {
+          message: "Path allocation already exists, payment method updated",
+          path: `m/44'/${body.coin_type}'/${body.account_index}'`,
+        },
+        200,
+      );
+    }
+
     return c.json({ id: body.id, path: `m/44'/${body.coin_type}'/${body.account_index}'` }, 201);
   });
 

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

@@ -15,6 +15,9 @@ const COINGECKO_IDS: Record<string, string> = {
   UNI: "uniswap",
   AERO: "aerodrome-finance",
   TRX: "tron",
+  BNB: "binancecoin",
+  POL: "matic-network",
+  AVAX: "avalanche-2",
 };
 
 /** Default cache TTL: 60 seconds. CoinGecko free tier allows 10-30 req/min. */

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

@@ -14,11 +14,13 @@ export interface PaymentMethodRecord {
   displayOrder: number;
   iconUrl: string | null;
   rpcUrl: string | null;
+  rpcHeaders: string;
   oracleAddress: string | null;
   xpub: string | null;
   addressType: string;
   encodingParams: string;
   watcherType: string;
+  oracleAssetId: string | null;
   confirmations: number;
 }
 
@@ -88,11 +90,13 @@ export class DrizzlePaymentMethodStore implements IPaymentMethodStore {
         displayOrder: method.displayOrder,
         iconUrl: method.iconUrl,
         rpcUrl: method.rpcUrl,
+        rpcHeaders: method.rpcHeaders ?? "{}",
         oracleAddress: method.oracleAddress,
         xpub: method.xpub,
         addressType: method.addressType,
         encodingParams: method.encodingParams,
         watcherType: method.watcherType,
+        oracleAssetId: method.oracleAssetId,
         confirmations: method.confirmations,
       })
       .onConflictDoUpdate({
@@ -113,6 +117,7 @@ export class DrizzlePaymentMethodStore implements IPaymentMethodStore {
           addressType: method.addressType,
           encodingParams: method.encodingParams,
           watcherType: method.watcherType,
+          oracleAssetId: method.oracleAssetId,
           confirmations: method.confirmations,
         },
       });
@@ -151,11 +156,13 @@ function toRecord(row: typeof paymentMethods.$inferSelect): PaymentMethodRecord
     displayOrder: row.displayOrder,
     iconUrl: row.iconUrl,
     rpcUrl: row.rpcUrl,
+    rpcHeaders: row.rpcHeaders ?? "{}",
     oracleAddress: row.oracleAddress,
     xpub: row.xpub,
     addressType: row.addressType,
     encodingParams: row.encodingParams,
     watcherType: row.watcherType,
+    oracleAssetId: row.oracleAssetId,
     confirmations: row.confirmations,
   };
 }

package/src/billing/crypto/tron/address-convert.ts

@@ -10,16 +10,25 @@ import { sha256 } from "@noble/hashes/sha2.js";
 const BASE58_ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
 
 function base58decode(s: string): Uint8Array {
+  // Count leading '1' characters (each represents a 0x00 byte)
+  let leadingZeros = 0;
+  for (const ch of s) {
+    if (ch !== "1") break;
+    leadingZeros++;
+  }
   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;
+  const hex = num.toString(16).padStart(2, "0");
+  const dataBytes = new Uint8Array(hex.length / 2);
+  for (let i = 0; i < dataBytes.length; i++) dataBytes[i] = Number.parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+  // Prepend leading zero bytes
+  const result = new Uint8Array(leadingZeros + dataBytes.length);
+  result.set(dataBytes, leadingZeros);
+  return result;
 }
 
 /**

package/src/billing/crypto/watcher-service.ts

@@ -360,19 +360,20 @@ 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;
+  // Address conversion for EVM-watched chains with non-0x address formats (Tron T...).
+  // Only applies to chains routed through the EVM watcher but storing non-hex addresses.
+  // UTXO chains (DOGE p2pkh) never enter this path — they use the UTXO watcher.
+  const isTronMethod = (method: { addressType: string; chain: string }): boolean =>
+    (method.addressType === "p2pkh" || method.addressType === "keccak-b58check") && method.chain === "tron";
+  const toWatcherAddr = (addr: string, method: { addressType: string; chain: string }): string =>
+    isTronMethod(method) && isTronAddress(addr) ? tronToHex(addr) : addr;
+  const fromWatcherAddr = (addr: string, method: { addressType: string; chain: string }): string =>
+    isTronMethod(method) ? hexToTron(addr) : addr;
 
   for (const method of nativeEvmMethods) {
     if (!method.rpcUrl) continue;
 
-    const rpcCall = createRpcCaller(method.rpcUrl);
+    const rpcCall = createRpcCaller(method.rpcUrl, JSON.parse(method.rpcHeaders ?? "{}"));
     let latestBlock: number;
     try {
       const latestHex = (await rpcCall("eth_blockNumber", [])) as string;
@@ -451,7 +452,7 @@ export async function startWatchers(opts: WatcherServiceOpts): Promise<() => voi
   for (const method of erc20Methods) {
     if (!method.rpcUrl || !method.contractAddress) continue;
 
-    const rpcCall = createRpcCaller(method.rpcUrl);
+    const rpcCall = createRpcCaller(method.rpcUrl, JSON.parse(method.rpcHeaders ?? "{}"));
     let latestBlock: number;
     try {
       const latestHex = (await rpcCall("eth_blockNumber", [])) as string;
@@ -470,7 +471,7 @@ export async function startWatchers(opts: WatcherServiceOpts): Promise<() => voi
       rpcCall,
       fromBlock: latestBlock,
       watchedAddresses: chainAddresses.map((a) => toWatcherAddr(a, method)),
-      contractAddress: method.contractAddress,
+      contractAddress: toWatcherAddr(method.contractAddress, method),
       decimals: method.decimals,
       confirmations: method.confirmations,
       cursorStore,

package/src/db/schema/crypto.ts

@@ -80,11 +80,13 @@ export const paymentMethods = pgTable("payment_methods", {
   displayOrder: integer("display_order").notNull().default(0),
   iconUrl: text("icon_url"),
   rpcUrl: text("rpc_url"), // chain node RPC endpoint
+  rpcHeaders: text("rpc_headers").notNull().default("{}"), // JSON: extra headers for RPC calls (e.g. {"TRON-PRO-API-KEY":"xxx"})
   oracleAddress: text("oracle_address"), // Chainlink feed address for price (null = 1:1 stablecoin)
   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)
+  addressType: text("address_type").notNull().default("evm"), // "bech32" (BTC/LTC), "p2pkh" (DOGE/TRX), "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)
+  oracleAssetId: text("oracle_asset_id"), // CoinGecko slug (e.g. "bitcoin", "tron"). Null = stablecoin (1:1 USD) or use token symbol fallback.
   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())`),