@wopr-network/platform-core 1.57.0 → 1.58.0

package/src/billing/crypto/__tests__/address-gen.test.ts

@@ -0,0 +1,145 @@
+import { HDKey } from "@scure/bip32";
+import { describe, expect, it } from "vitest";
+import { deriveAddress, deriveTreasury, isValidXpub } from "../address-gen.js";
+
+function makeTestXpub(path: string): string {
+  const seed = new Uint8Array(32);
+  seed[0] = 1;
+  const master = HDKey.fromMasterSeed(seed);
+  return master.derive(path).publicExtendedKey;
+}
+
+const BTC_XPUB = makeTestXpub("m/44'/0'/0'");
+const ETH_XPUB = makeTestXpub("m/44'/60'/0'");
+
+describe("deriveAddress — bech32 (BTC)", () => {
+  it("derives a valid bc1q address", () => {
+    const addr = deriveAddress(BTC_XPUB, 0, "bech32", { hrp: "bc" });
+    expect(addr).toMatch(/^bc1q[a-z0-9]+$/);
+  });
+
+  it("derives different addresses for different indices", () => {
+    const a = deriveAddress(BTC_XPUB, 0, "bech32", { hrp: "bc" });
+    const b = deriveAddress(BTC_XPUB, 1, "bech32", { hrp: "bc" });
+    expect(a).not.toBe(b);
+  });
+
+  it("is deterministic", () => {
+    const a = deriveAddress(BTC_XPUB, 42, "bech32", { hrp: "bc" });
+    const b = deriveAddress(BTC_XPUB, 42, "bech32", { hrp: "bc" });
+    expect(a).toBe(b);
+  });
+
+  it("uses tb prefix for testnet", () => {
+    const addr = deriveAddress(BTC_XPUB, 0, "bech32", { hrp: "tb" });
+    expect(addr).toMatch(/^tb1q[a-z0-9]+$/);
+  });
+
+  it("rejects negative index", () => {
+    expect(() => deriveAddress(BTC_XPUB, -1, "bech32", { hrp: "bc" })).toThrow("Invalid");
+  });
+
+  it("throws without hrp param", () => {
+    expect(() => deriveAddress(BTC_XPUB, 0, "bech32", {})).toThrow("hrp");
+  });
+});
+
+describe("deriveAddress — bech32 (LTC)", () => {
+  const LTC_XPUB = makeTestXpub("m/44'/2'/0'");
+
+  it("derives a valid ltc1q address", () => {
+    const addr = deriveAddress(LTC_XPUB, 0, "bech32", { hrp: "ltc" });
+    expect(addr).toMatch(/^ltc1q[a-z0-9]+$/);
+  });
+});
+
+describe("deriveAddress — p2pkh (DOGE)", () => {
+  const DOGE_XPUB = makeTestXpub("m/44'/3'/0'");
+
+  it("derives a valid D... address", () => {
+    const addr = deriveAddress(DOGE_XPUB, 0, "p2pkh", { version: "0x1e" });
+    expect(addr).toMatch(/^D[a-km-zA-HJ-NP-Z1-9]+$/);
+  });
+
+  it("derives different addresses for different indices", () => {
+    const a = deriveAddress(DOGE_XPUB, 0, "p2pkh", { version: "0x1e" });
+    const b = deriveAddress(DOGE_XPUB, 1, "p2pkh", { version: "0x1e" });
+    expect(a).not.toBe(b);
+  });
+
+  it("throws without version param", () => {
+    expect(() => deriveAddress(DOGE_XPUB, 0, "p2pkh", {})).toThrow("version");
+  });
+});
+
+describe("deriveAddress — p2pkh (TRON)", () => {
+  const TRON_XPUB = makeTestXpub("m/44'/195'/0'");
+
+  it("derives a valid T... address", () => {
+    const addr = deriveAddress(TRON_XPUB, 0, "p2pkh", { version: "0x41" });
+    expect(addr).toMatch(/^T[a-km-zA-HJ-NP-Z1-9]+$/);
+  });
+
+  it("is deterministic", () => {
+    const a = deriveAddress(TRON_XPUB, 5, "p2pkh", { version: "0x41" });
+    const b = deriveAddress(TRON_XPUB, 5, "p2pkh", { version: "0x41" });
+    expect(a).toBe(b);
+  });
+});
+
+describe("deriveAddress — evm (ETH)", () => {
+  it("derives a valid Ethereum address", () => {
+    const addr = deriveAddress(ETH_XPUB, 0, "evm");
+    expect(addr).toMatch(/^0x[0-9a-fA-F]{40}$/);
+  });
+
+  it("derives different addresses for different indices", () => {
+    const a = deriveAddress(ETH_XPUB, 0, "evm");
+    const b = deriveAddress(ETH_XPUB, 1, "evm");
+    expect(a).not.toBe(b);
+  });
+
+  it("is deterministic", () => {
+    const a = deriveAddress(ETH_XPUB, 42, "evm");
+    const b = deriveAddress(ETH_XPUB, 42, "evm");
+    expect(a).toBe(b);
+  });
+
+  it("returns checksummed address", () => {
+    const addr = deriveAddress(ETH_XPUB, 0, "evm");
+    expect(addr).toMatch(/^0x[0-9a-fA-F]{40}$/);
+  });
+});
+
+describe("deriveAddress — unknown type", () => {
+  it("throws for unknown address type", () => {
+    expect(() => deriveAddress(BTC_XPUB, 0, "foo")).toThrow("Unknown address type");
+  });
+});
+
+describe("deriveTreasury", () => {
+  it("derives a valid bech32 treasury address", () => {
+    const addr = deriveTreasury(BTC_XPUB, "bech32", { hrp: "bc" });
+    expect(addr).toMatch(/^bc1q[a-z0-9]+$/);
+  });
+
+  it("differs from deposit address at index 0", () => {
+    const deposit = deriveAddress(BTC_XPUB, 0, "bech32", { hrp: "bc" });
+    const treasury = deriveTreasury(BTC_XPUB, "bech32", { hrp: "bc" });
+    expect(deposit).not.toBe(treasury);
+  });
+});
+
+describe("isValidXpub", () => {
+  it("accepts valid xpub", () => {
+    expect(isValidXpub(BTC_XPUB)).toBe(true);
+  });
+
+  it("rejects garbage", () => {
+    expect(isValidXpub("not-an-xpub")).toBe(false);
+  });
+
+  it("rejects empty string", () => {
+    expect(isValidXpub("")).toBe(false);
+  });
+});

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

@@ -15,6 +15,7 @@ function createMockDb() {
     nextIndex: 1,
     decimals: 8,
     addressType: "bech32",
+    encodingParams: '{"hrp":"bc"}',
     confirmations: 6,
   };
 
@@ -195,6 +196,7 @@ describe("key-server routes", () => {
       nextIndex: 0,
       decimals: 18,
       addressType: "evm",
+      encodingParams: "{}",
       confirmations: 1,
     };
 
@@ -258,6 +260,7 @@ describe("key-server routes", () => {
       nextIndex: 0,
       decimals: 18,
       addressType: "evm",
+      encodingParams: "{}",
       confirmations: 1,
     };
 

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

@@ -0,0 +1,146 @@
+/**
+ * Universal address derivation — one function for all secp256k1 chains.
+ *
+ * Encoding type and chain-specific params (HRP, version byte) are read from
+ * the paymentMethods DB row, not hardcoded per chain. Adding a new chain
+ * is a DB INSERT, not a code change.
+ *
+ * Supported encodings:
+ *   - bech32:  BTC (bc1q...), LTC (ltc1q...) — params: { hrp }
+ *   - p2pkh:   DOGE (D...), TRON (T...) — params: { version }
+ *   - evm:     ETH, ERC-20 (0x...) — params: {}
+ */
+import { ripemd160 } from "@noble/hashes/legacy.js";
+import { sha256 } from "@noble/hashes/sha2.js";
+import { bech32 } from "@scure/base";
+import { HDKey } from "@scure/bip32";
+import { publicKeyToAddress } from "viem/accounts";
+
+export interface EncodingParams {
+  /** Bech32 human-readable prefix (e.g. "bc", "ltc", "tb"). */
+  hrp?: string;
+  /** Base58Check version byte as hex string (e.g. "0x1e" for DOGE, "0x41" for TRON). */
+  version?: string;
+}
+
+// ---------- encoding helpers ----------
+
+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;
+}
+
+function hash160(pubkey: Uint8Array): Uint8Array {
+  return ripemd160(sha256(pubkey));
+}
+
+function encodeBech32(pubkey: Uint8Array, hrp: string): string {
+  const h = hash160(pubkey);
+  const words = bech32.toWords(h);
+  return bech32.encode(hrp, [0, ...words]);
+}
+
+function encodeP2pkh(pubkey: Uint8Array, versionByte: number): string {
+  const h = hash160(pubkey);
+  const payload = new Uint8Array(21);
+  payload[0] = versionByte;
+  payload.set(h, 1);
+  const checksum = sha256(sha256(payload));
+  const full = new Uint8Array(25);
+  full.set(payload);
+  full.set(checksum.slice(0, 4), 21);
+  return base58encode(full);
+}
+
+function encodeEvm(pubkey: Uint8Array): string {
+  const hexPubKey = `0x${Array.from(pubkey, (b) => b.toString(16).padStart(2, "0")).join("")}` as `0x${string}`;
+  return publicKeyToAddress(hexPubKey);
+}
+
+// ---------- public API ----------
+
+/**
+ * Derive a deposit address from an xpub at a given BIP-44 index.
+ * Path: xpub / 0 / index (external chain).
+ * No private keys involved.
+ *
+ * @param xpub - Extended public key
+ * @param index - Derivation index (0, 1, 2, ...)
+ * @param addressType - Encoding type: "bech32", "p2pkh", "evm"
+ * @param params - Chain-specific encoding params from DB (parsed JSON)
+ */
+export function deriveAddress(xpub: string, index: number, addressType: string, params: EncodingParams = {}): string {
+  if (!Number.isInteger(index) || index < 0) throw new Error(`Invalid derivation index: ${index}`);
+
+  const master = HDKey.fromExtendedKey(xpub);
+  const child = master.deriveChild(0).deriveChild(index);
+  if (!child.publicKey) throw new Error("Failed to derive public key");
+
+  switch (addressType) {
+    case "bech32": {
+      if (!params.hrp) throw new Error("bech32 encoding requires 'hrp' param");
+      return encodeBech32(child.publicKey, params.hrp);
+    }
+    case "p2pkh": {
+      if (!params.version) throw new Error("p2pkh encoding requires 'version' param");
+      const versionByte = Number(params.version);
+      if (!Number.isInteger(versionByte) || versionByte < 0 || versionByte > 255)
+        throw new Error(`Invalid p2pkh version byte: ${params.version}`);
+      return encodeP2pkh(child.publicKey, versionByte);
+    }
+    case "evm":
+      return encodeEvm(child.publicKey);
+    default:
+      throw new Error(`Unknown address type: ${addressType}`);
+  }
+}
+
+/**
+ * Derive the treasury address (internal chain, index 0).
+ * Used for sweep destinations.
+ */
+export function deriveTreasury(xpub: string, addressType: string, params: EncodingParams = {}): string {
+  const master = HDKey.fromExtendedKey(xpub);
+  const child = master.deriveChild(1).deriveChild(0); // internal chain
+  if (!child.publicKey) throw new Error("Failed to derive public key");
+
+  switch (addressType) {
+    case "bech32": {
+      if (!params.hrp) throw new Error("bech32 encoding requires 'hrp' param");
+      return encodeBech32(child.publicKey, params.hrp);
+    }
+    case "p2pkh": {
+      if (!params.version) throw new Error("p2pkh encoding requires 'version' param");
+      const versionByte = Number(params.version);
+      if (!Number.isInteger(versionByte) || versionByte < 0 || versionByte > 255)
+        throw new Error(`Invalid p2pkh version byte: ${params.version}`);
+      return encodeP2pkh(child.publicKey, versionByte);
+    }
+    case "evm":
+      return encodeEvm(child.publicKey);
+    default:
+      throw new Error(`Unknown address type: ${addressType}`);
+  }
+}
+
+/** Validate that a string is an xpub (not xprv). */
+export function isValidXpub(key: string): boolean {
+  if (!key.startsWith("xpub")) return false;
+  try {
+    HDKey.fromExtendedKey(key);
+    return true;
+  } catch {
+    return false;
+  }
+}

package/src/billing/crypto/btc/checkout.ts

@@ -1,6 +1,6 @@
 import { Credit } from "../../../credits/credit.js";
+import { deriveAddress } from "../address-gen.js";
 import type { ICryptoChargeRepository } from "../charge-store.js";
-import { deriveBtcAddress } from "./address-gen.js";
 import type { BtcCheckoutOpts } from "./types.js";
 
 export const MIN_BTC_USD = 10;
@@ -35,7 +35,10 @@ export async function createBtcCheckout(deps: BtcCheckoutDeps, opts: BtcCheckout
 
   for (let attempt = 0; attempt <= maxRetries; attempt++) {
     const derivationIndex = await deps.chargeStore.getNextDerivationIndex();
-    const depositAddress = deriveBtcAddress(deps.xpub, derivationIndex, network);
+    const hrpMap = { mainnet: "bc", testnet: "tb", regtest: "bcrt" } as const;
+    const depositAddress = deriveAddress(deps.xpub, derivationIndex, "bech32", {
+      hrp: hrpMap[network],
+    });
     const referenceId = `btc:${depositAddress}`;
 
     try {

package/src/billing/crypto/btc/index.ts

@@ -1,5 +1,5 @@
-export type { UtxoChain, UtxoNetwork } from "./address-gen.js";
-export { deriveAddress, deriveBtcAddress, deriveBtcTreasury, deriveTreasury } from "./address-gen.js";
+export type { EncodingParams } from "../address-gen.js";
+export { deriveAddress, deriveTreasury, isValidXpub } from "../address-gen.js";
 export type { BtcCheckoutDeps, BtcCheckoutResult } from "./checkout.js";
 export { createBtcCheckout, MIN_BTC_USD } from "./checkout.js";
 export { centsToSats, loadBitcoindConfig, satsToCents } from "./config.js";

package/src/billing/crypto/evm/checkout.ts

@@ -1,6 +1,6 @@
 import { Credit } from "../../../credits/credit.js";
+import { deriveAddress } from "../address-gen.js";
 import type { ICryptoChargeRepository } from "../charge-store.js";
-import { deriveDepositAddress } from "./address-gen.js";
 import { getTokenConfig, tokenAmountFromCents } from "./config.js";
 import type { StablecoinCheckoutOpts } from "./types.js";
 
@@ -47,7 +47,7 @@ export async function createStablecoinCheckout(
   const maxRetries = 3;
   for (let attempt = 0; attempt <= maxRetries; attempt++) {
     const derivationIndex = await deps.chargeStore.getNextDerivationIndex();
-    const depositAddress = deriveDepositAddress(deps.xpub, derivationIndex);
+    const depositAddress = deriveAddress(deps.xpub, derivationIndex, "evm");
     const referenceId = `sc:${opts.chain}:${opts.token.toLowerCase()}:${depositAddress.toLowerCase()}`;
 
     try {

package/src/billing/crypto/evm/eth-checkout.ts

@@ -1,8 +1,8 @@
 import { Credit } from "../../../credits/credit.js";
+import { deriveAddress } from "../address-gen.js";
 import type { ICryptoChargeRepository } from "../charge-store.js";
 import { centsToNative } from "../oracle/convert.js";
 import type { IPriceOracle } from "../oracle/types.js";
-import { deriveDepositAddress } from "./address-gen.js";
 import type { EvmChain } from "./types.js";
 
 export const MIN_ETH_USD = 10;
@@ -51,7 +51,7 @@ export async function createEthCheckout(deps: EthCheckoutDeps, opts: EthCheckout
 
   for (let attempt = 0; attempt <= maxRetries; attempt++) {
     const derivationIndex = await deps.chargeStore.getNextDerivationIndex();
-    const depositAddress = deriveDepositAddress(deps.xpub, derivationIndex);
+    const depositAddress = deriveAddress(deps.xpub, derivationIndex, "evm") as `0x${string}`;
     const referenceId = `eth:${opts.chain}:${depositAddress}`;
 
     try {

package/src/billing/crypto/evm/index.ts

@@ -1,4 +1,5 @@
-export { deriveDepositAddress, isValidXpub } from "./address-gen.js";
+export type { EncodingParams } from "../address-gen.js";
+export { deriveAddress, isValidXpub } from "../address-gen.js";
 export type { StablecoinCheckoutDeps, StablecoinCheckoutResult } from "./checkout.js";
 export { createStablecoinCheckout, MIN_STABLECOIN_USD } from "./checkout.js";
 export { centsFromTokenAmount, getChainConfig, getTokenConfig, tokenAmountFromCents } from "./config.js";

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

@@ -11,9 +11,9 @@ import { eq, sql } from "drizzle-orm";
 import { Hono } from "hono";
 import type { DrizzleDb } from "../../db/index.js";
 import { derivedAddresses, pathAllocations, paymentMethods } from "../../db/schema/crypto.js";
-import { deriveAddress, deriveP2pkhAddress } from "./btc/address-gen.js";
+import type { EncodingParams } from "./address-gen.js";
+import { deriveAddress } from "./address-gen.js";
 import type { ICryptoChargeRepository } from "./charge-store.js";
-import { deriveDepositAddress } from "./evm/address-gen.js";
 import { centsToNative } from "./oracle/convert.js";
 import type { IPriceOracle } from "./oracle/types.js";
 import { AssetNotSupportedError } from "./oracle/types.js";
@@ -60,26 +60,15 @@ async function deriveNextAddress(
 
     const index = method.nextIndex - 1;
 
-    // Route to the right derivation function via address_type (DB-driven, no hardcoded chains)
-    let address: string;
-    switch (method.addressType) {
-      case "bech32":
-        address = deriveAddress(
-          method.xpub,
-          index,
-          (method.network ?? "mainnet") as "mainnet" | "testnet" | "regtest",
-          method.chain as "bitcoin" | "litecoin",
-        );
-        break;
-      case "p2pkh":
-        address = deriveP2pkhAddress(method.xpub, index, method.chain);
-        break;
-      case "evm":
-        address = deriveDepositAddress(method.xpub, index);
-        break;
-      default:
-        throw new Error(`Unknown address type: ${method.addressType}`);
+    // Universal address derivation — encoding type + params are DB-driven.
+    // Adding a new chain is a DB INSERT, not a code change.
+    let encodingParams: EncodingParams = {};
+    try {
+      encodingParams = JSON.parse(method.encodingParams ?? "{}");
+    } catch {
+      throw new Error(`Invalid encoding_params JSON for chain ${chainId}: ${method.encodingParams}`);
     }
+    const address = deriveAddress(method.xpub, index, method.addressType, encodingParams);
 
     // Step 2: Record in immutable log. If this address was already derived by a
     // sibling chain (shared xpub), the unique constraint fires and we retry
@@ -218,9 +207,12 @@ export function createKeyServerApp(deps: KeyServerDeps): Hono {
       expectedAmount: expectedAmount.toString(),
     });
 
-    // Format display amount for the client
-    const divisor = 10 ** method.decimals;
-    const displayAmount = `${(Number(expectedAmount) / divisor).toFixed(Math.min(method.decimals, 8))} ${token}`;
+    // Format display amount for the client (BigInt-safe, no Number overflow)
+    const divisor = 10n ** BigInt(method.decimals);
+    const whole = expectedAmount / divisor;
+    const frac = expectedAmount % divisor;
+    const fracStr = frac.toString().padStart(method.decimals, "0").slice(0, 8).replace(/0+$/, "");
+    const displayAmount = `${whole}${fracStr ? `.${fracStr}` : ""} ${token}`;
 
     return c.json(
       {
@@ -329,6 +321,7 @@ export function createKeyServerApp(deps: KeyServerDeps): Hono {
       display_name?: string;
       oracle_address?: string;
       address_type?: string;
+      encoding_params?: Record<string, string>;
       icon_url?: string;
       display_order?: number;
     }>();
@@ -355,6 +348,16 @@ export function createKeyServerApp(deps: KeyServerDeps): Hono {
       );
     }
 
+    // Validate encoding_params match address_type requirements
+    const addrType = body.address_type ?? "evm";
+    const encParams = body.encoding_params ?? {};
+    if (addrType === "bech32" && !encParams.hrp) {
+      return c.json({ error: "bech32 address_type requires encoding_params.hrp" }, 400);
+    }
+    if (addrType === "p2pkh" && !encParams.version) {
+      return c.json({ error: "p2pkh address_type requires encoding_params.version" }, 400);
+    }
+
     // Upsert the payment method
     await deps.methodStore.upsert({
       id: body.id,
@@ -371,6 +374,7 @@ export function createKeyServerApp(deps: KeyServerDeps): Hono {
       oracleAddress: body.oracle_address ?? null,
       xpub: body.xpub,
       addressType: body.address_type ?? "evm",
+      encodingParams: JSON.stringify(body.encoding_params ?? {}),
       confirmations: body.confirmations ?? 6,
     });
 

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

@@ -17,6 +17,7 @@ export interface PaymentMethodRecord {
   oracleAddress: string | null;
   xpub: string | null;
   addressType: string;
+  encodingParams: string;
   confirmations: number;
 }
 
@@ -89,6 +90,7 @@ export class DrizzlePaymentMethodStore implements IPaymentMethodStore {
         oracleAddress: method.oracleAddress,
         xpub: method.xpub,
         addressType: method.addressType,
+        encodingParams: method.encodingParams,
         confirmations: method.confirmations,
       })
       .onConflictDoUpdate({
@@ -107,6 +109,7 @@ export class DrizzlePaymentMethodStore implements IPaymentMethodStore {
           oracleAddress: method.oracleAddress,
           xpub: method.xpub,
           addressType: method.addressType,
+          encodingParams: method.encodingParams,
           confirmations: method.confirmations,
         },
       });
@@ -148,6 +151,7 @@ function toRecord(row: typeof paymentMethods.$inferSelect): PaymentMethodRecord
     oracleAddress: row.oracleAddress,
     xpub: row.xpub,
     addressType: row.addressType,
+    encodingParams: row.encodingParams,
     confirmations: row.confirmations,
   };
 }

package/src/db/schema/crypto.ts

@@ -83,6 +83,7 @@ export const paymentMethods = pgTable("payment_methods", {
   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)
+  encodingParams: text("encoding_params").notNull().default("{}"), // JSON: {"hrp":"bc"}, {"version":"0x1e"}, etc.
   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/billing/crypto/btc/__tests__/address-gen.test.js

@@ -1,44 +0,0 @@
-import { HDKey } from "@scure/bip32";
-import { describe, expect, it } from "vitest";
-import { deriveBtcAddress, deriveBtcTreasury } from "../address-gen.js";
-function makeTestXpub() {
-    const seed = new Uint8Array(32);
-    seed[0] = 1;
-    const master = HDKey.fromMasterSeed(seed);
-    return master.derive("m/44'/0'/0'").publicExtendedKey;
-}
-const TEST_XPUB = makeTestXpub();
-describe("deriveBtcAddress", () => {
-    it("derives a valid bech32 address", () => {
-        const addr = deriveBtcAddress(TEST_XPUB, 0);
-        expect(addr).toMatch(/^bc1q[a-z0-9]+$/);
-    });
-    it("derives different addresses for different indices", () => {
-        const a = deriveBtcAddress(TEST_XPUB, 0);
-        const b = deriveBtcAddress(TEST_XPUB, 1);
-        expect(a).not.toBe(b);
-    });
-    it("is deterministic", () => {
-        const a = deriveBtcAddress(TEST_XPUB, 42);
-        const b = deriveBtcAddress(TEST_XPUB, 42);
-        expect(a).toBe(b);
-    });
-    it("uses tb prefix for testnet/regtest", () => {
-        const addr = deriveBtcAddress(TEST_XPUB, 0, "testnet");
-        expect(addr).toMatch(/^tb1q[a-z0-9]+$/);
-    });
-    it("rejects negative index", () => {
-        expect(() => deriveBtcAddress(TEST_XPUB, -1)).toThrow("Invalid");
-    });
-});
-describe("deriveBtcTreasury", () => {
-    it("derives a valid bech32 address", () => {
-        const addr = deriveBtcTreasury(TEST_XPUB);
-        expect(addr).toMatch(/^bc1q[a-z0-9]+$/);
-    });
-    it("differs from deposit address at index 0", () => {
-        const deposit = deriveBtcAddress(TEST_XPUB, 0);
-        const treasury = deriveBtcTreasury(TEST_XPUB);
-        expect(deposit).not.toBe(treasury);
-    });
-});

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

@@ -1,23 +0,0 @@
-/** Supported UTXO chains for bech32 address derivation. */
-export type UtxoChain = "bitcoin" | "litecoin";
-/** Supported network types. */
-export type UtxoNetwork = "mainnet" | "testnet" | "regtest";
-/**
- * Derive a native segwit (bech32) deposit address from an xpub at a given index.
- * Works for BTC (bc1q...) and LTC (ltc1q...) — same HASH160 + bech32 encoding.
- * Path: xpub / 0 / index (external chain).
- * No private keys involved.
- */
-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. */
-export declare const deriveBtcTreasury: typeof deriveTreasury;
-/** Validate that a string is an xpub (not xprv). */
-export declare function isValidXpub(key: string): boolean;