@wopr-network/platform-core 1.34.0 → 1.35.0

package/dist/billing/crypto/btc/address-gen.d.ts

@@ -11,6 +11,10 @@ export type UtxoNetwork = "mainnet" | "testnet" | "regtest";
 export declare function deriveAddress(xpub: string, index: number, network?: UtxoNetwork, chain?: UtxoChain): string;
 /** Derive the treasury address (internal chain, index 0). */
 export declare function deriveTreasury(xpub: string, network?: UtxoNetwork, chain?: UtxoChain): string;
+/**
+ * Derive a P2PKH (Base58Check) address for chains without bech32 (e.g., DOGE → D...).
+ */
+export declare function deriveP2pkhAddress(xpub: string, index: number, chain: string, network?: "mainnet" | "testnet"): string;
 /** @deprecated Use `deriveAddress` instead. */
 export declare const deriveBtcAddress: typeof deriveAddress;
 /** @deprecated Use `deriveTreasury` instead. */

package/dist/billing/crypto/btc/address-gen.js

@@ -39,6 +39,50 @@ export function deriveTreasury(xpub, network = "mainnet", chain = "bitcoin") {
     const words = bech32.toWords(hash160);
     return bech32.encode(prefix, [0, ...words]);
 }
+/** P2PKH version bytes for Base58Check encoding (chains without bech32). */
+const P2PKH_VERSION = {
+    dogecoin: { mainnet: 0x1e, testnet: 0x71 },
+};
+const BASE58_ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+function base58encode(data) {
+    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, index, chain, network = "mainnet") {
+    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;
 /** @deprecated Use `deriveTreasury` instead. */

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

@@ -25,11 +25,11 @@ export class ChainlinkOracle {
     maxStalenessMs;
     constructor(opts) {
         this.rpc = opts.rpcCall;
-        this.feeds = { ...FEED_ADDRESSES, ...opts.feedAddresses };
+        this.feeds = new Map(Object.entries({ ...FEED_ADDRESSES, ...opts.feedAddresses }));
         this.maxStalenessMs = opts.maxStalenessMs ?? DEFAULT_MAX_STALENESS_MS;
     }
     async getPrice(asset) {
-        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"]));

package/dist/billing/crypto/oracle/types.d.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 {
     /** USD cents per 1 unit of asset (integer). */

package/dist/billing/crypto/unified-checkout.js

@@ -1,4 +1,5 @@
 import { Credit } from "../../credits/credit.js";
+import { deriveAddress, deriveP2pkhAddress } from "./btc/address-gen.js";
 import { deriveDepositAddress } from "./evm/address-gen.js";
 import { centsToNative } from "./oracle/convert.js";
 export const MIN_CHECKOUT_USD = 10;
@@ -20,11 +21,11 @@ export async function createUnifiedCheckout(deps, method, opts) {
     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}`);
 }
@@ -39,7 +40,7 @@ async function handleErc20(deps, method, tenant, amountUsdCents, amountUsd) {
         referenceId: `erc20:${method.chain}:${depositAddress}`,
     };
 }
-async function handleNativeEth(deps, method, tenant, amountUsdCents, amountUsd) {
+async function handleNativeEvm(deps, method, tenant, amountUsdCents, amountUsd) {
     const { priceCents } = await deps.oracle.getPrice("ETH");
     const expectedWei = centsToNative(amountUsdCents, priceCents, 18);
     const depositAddress = await deriveAndStore(deps, method, tenant, amountUsdCents);
@@ -56,35 +57,47 @@ async function handleNativeEth(deps, method, tenant, amountUsdCents, amountUsd)
         priceCents,
     };
 }
-async function handleNativeBtc(deps, _method, tenant, amountUsdCents, amountUsd) {
-    const { priceCents } = await deps.oracle.getPrice("BTC");
-    const expectedSats = centsToNative(amountUsdCents, priceCents, 8);
-    // 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)");
+/**
+ * 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, method, tenant, amountUsdCents, amountUsd) {
+    const xpub = method.xpub ?? deps.btcXpub;
+    if (!xpub)
+        throw new Error(`${method.token} payments not configured (no 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;
+        if (method.chain === "dogecoin") {
+            depositAddress = deriveP2pkhAddress(xpub, derivationIndex, "dogecoin");
+        }
+        else {
+            depositAddress = deriveAddress(xpub, derivationIndex, "mainnet", method.chain);
+        }
+        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,
             };

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.0",
   "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,
       };