@wopr-network/platform-core 1.20.0 → 1.22.0

package/dist/billing/crypto/evm/index.d.ts

@@ -2,6 +2,12 @@ export { deriveDepositAddress, 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";
+export type { EthCheckoutDeps, EthCheckoutOpts, EthCheckoutResult } from "./eth-checkout.js";
+export { createEthCheckout, MIN_ETH_USD } from "./eth-checkout.js";
+export type { EthSettlerDeps } from "./eth-settler.js";
+export { settleEthPayment } from "./eth-settler.js";
+export type { EthPaymentEvent, EthWatcherOpts } from "./eth-watcher.js";
+export { EthWatcher } from "./eth-watcher.js";
 export type { EvmSettlerDeps } from "./settler.js";
 export { settleEvmPayment } from "./settler.js";
 export type { ChainConfig, EvmChain, EvmPaymentEvent, StablecoinCheckoutOpts, StablecoinToken, TokenConfig, } from "./types.js";

package/dist/billing/crypto/evm/index.js

@@ -1,5 +1,8 @@
 export { deriveDepositAddress, isValidXpub } from "./address-gen.js";
 export { createStablecoinCheckout, MIN_STABLECOIN_USD } from "./checkout.js";
 export { centsFromTokenAmount, getChainConfig, getTokenConfig, tokenAmountFromCents } from "./config.js";
+export { createEthCheckout, MIN_ETH_USD } from "./eth-checkout.js";
+export { settleEthPayment } from "./eth-settler.js";
+export { EthWatcher } from "./eth-watcher.js";
 export { settleEvmPayment } from "./settler.js";
 export { createRpcCaller, EvmWatcher } from "./watcher.js";

package/dist/billing/crypto/evm/settler.js

@@ -16,7 +16,7 @@ export async function settleEvmPayment(deps, event) {
     const { chargeStore, creditLedger } = deps;
     const charge = await chargeStore.getByDepositAddress(event.to.toLowerCase());
     if (!charge) {
-        return { handled: false, status: "Settled" };
+        return { handled: false, status: "Invalid" };
     }
     // Update charge status to Settled.
     await chargeStore.updateStatus(charge.referenceId, "Settled");

package/dist/billing/crypto/index.d.ts

@@ -5,6 +5,7 @@ export { createCryptoCheckout, MIN_PAYMENT_USD } from "./checkout.js";
 export type { CryptoConfig } from "./client.js";
 export { BTCPayClient, loadCryptoConfig } from "./client.js";
 export * from "./evm/index.js";
+export * from "./oracle/index.js";
 export type { CryptoBillingConfig, CryptoCheckoutOpts, CryptoPaymentState, CryptoWebhookPayload, CryptoWebhookResult, } from "./types.js";
 export { mapBtcPayEventToStatus } from "./types.js";
 export type { CryptoWebhookDeps } from "./webhook.js";

package/dist/billing/crypto/index.js

@@ -3,5 +3,6 @@ export { CryptoChargeRepository, DrizzleCryptoChargeRepository } from "./charge-
 export { createCryptoCheckout, MIN_PAYMENT_USD } from "./checkout.js";
 export { BTCPayClient, loadCryptoConfig } from "./client.js";
 export * from "./evm/index.js";
+export * from "./oracle/index.js";
 export { mapBtcPayEventToStatus } from "./types.js";
 export { handleCryptoWebhook, verifyCryptoWebhookSignature } from "./webhook.js";

package/dist/billing/crypto/oracle/__tests__/chainlink.test.d.ts

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

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

@@ -0,0 +1,83 @@
+import { describe, expect, it, vi } from "vitest";
+import { ChainlinkOracle } from "../chainlink.js";
+/**
+ * Encode a mock latestRoundData() response.
+ * Chainlink returns 5 × 32-byte ABI-encoded words:
+ *   roundId, answer, startedAt, updatedAt, answeredInRound
+ */
+function encodeRoundData(answer, updatedAtSec) {
+    const pad = (v) => v.toString(16).padStart(64, "0");
+    return ("0x" +
+        pad(1n) + // roundId
+        pad(answer) + // answer (price × 10^8)
+        pad(BigInt(updatedAtSec)) + // startedAt
+        pad(BigInt(updatedAtSec)) + // updatedAt
+        pad(1n) // answeredInRound
+    );
+}
+describe("ChainlinkOracle", () => {
+    const nowSec = Math.floor(Date.now() / 1000);
+    it("decodes ETH/USD price from latestRoundData", async () => {
+        // ETH at $3,500.00 → answer = 3500 × 10^8 = 350_000_000_000
+        const rpc = vi.fn().mockResolvedValue(encodeRoundData(350000000000n, nowSec));
+        const oracle = new ChainlinkOracle({ rpcCall: rpc });
+        const result = await oracle.getPrice("ETH");
+        expect(result.priceCents).toBe(350_000); // $3,500.00
+        expect(result.updatedAt).toBeInstanceOf(Date);
+        expect(rpc).toHaveBeenCalledWith("eth_call", [
+            { to: "0x71041dddad3595F9CEd3DcCFBe3D1F4b0a16Bb70", data: "0xfeaf968c" },
+            "latest",
+        ]);
+    });
+    it("decodes BTC/USD price from latestRoundData", async () => {
+        // BTC at $65,000.00 → answer = 65000 × 10^8 = 6_500_000_000_000
+        const rpc = vi.fn().mockResolvedValue(encodeRoundData(6500000000000n, nowSec));
+        const oracle = new ChainlinkOracle({ rpcCall: rpc });
+        const result = await oracle.getPrice("BTC");
+        expect(result.priceCents).toBe(6_500_000); // $65,000.00
+    });
+    it("handles fractional dollar prices correctly", async () => {
+        // ETH at $3,456.78 → answer = 345_678_000_000
+        const rpc = vi.fn().mockResolvedValue(encodeRoundData(345678000000n, nowSec));
+        const oracle = new ChainlinkOracle({ rpcCall: rpc });
+        const result = await oracle.getPrice("ETH");
+        expect(result.priceCents).toBe(345_678); // $3,456.78
+    });
+    it("rejects stale prices", async () => {
+        const staleTime = nowSec - 7200; // 2 hours ago
+        const rpc = vi.fn().mockResolvedValue(encodeRoundData(350000000000n, staleTime));
+        const oracle = new ChainlinkOracle({ rpcCall: rpc, maxStalenessMs: 3600_000 });
+        await expect(oracle.getPrice("ETH")).rejects.toThrow("stale");
+    });
+    it("rejects zero price", async () => {
+        const rpc = vi.fn().mockResolvedValue(encodeRoundData(0n, nowSec));
+        const oracle = new ChainlinkOracle({ rpcCall: rpc });
+        await expect(oracle.getPrice("ETH")).rejects.toThrow("Invalid price");
+    });
+    it("rejects malformed response", async () => {
+        const rpc = vi.fn().mockResolvedValue("0xdead");
+        const oracle = new ChainlinkOracle({ rpcCall: rpc });
+        await expect(oracle.getPrice("ETH")).rejects.toThrow("Malformed");
+    });
+    it("accepts custom feed addresses", async () => {
+        const customFeed = "0x1234567890abcdef1234567890abcdef12345678";
+        const rpc = vi.fn().mockResolvedValue(encodeRoundData(350000000000n, nowSec));
+        const oracle = new ChainlinkOracle({
+            rpcCall: rpc,
+            feedAddresses: { ETH: customFeed },
+        });
+        await oracle.getPrice("ETH");
+        expect(rpc).toHaveBeenCalledWith("eth_call", [{ to: customFeed, data: "0xfeaf968c" }, "latest"]);
+    });
+    it("respects custom staleness threshold", async () => {
+        const thirtyMinAgo = nowSec - 1800;
+        const rpc = vi.fn().mockResolvedValue(encodeRoundData(350000000000n, thirtyMinAgo));
+        // 20-minute threshold → stale
+        const strict = new ChainlinkOracle({ rpcCall: rpc, maxStalenessMs: 20 * 60 * 1000 });
+        await expect(strict.getPrice("ETH")).rejects.toThrow("stale");
+        // 60-minute threshold → fresh
+        const relaxed = new ChainlinkOracle({ rpcCall: rpc, maxStalenessMs: 60 * 60 * 1000 });
+        const result = await relaxed.getPrice("ETH");
+        expect(result.priceCents).toBe(350_000);
+    });
+});

package/dist/billing/crypto/oracle/__tests__/convert.test.d.ts

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

package/dist/billing/crypto/oracle/__tests__/convert.test.js

@@ -0,0 +1,51 @@
+import { describe, expect, it } from "vitest";
+import { centsToNative, nativeToCents } from "../convert.js";
+describe("centsToNative", () => {
+    it("converts $50 to ETH wei at $3,500", () => {
+        // 5000 cents × 10^18 / 350000 cents = 14285714285714285n wei
+        const wei = centsToNative(5000, 350_000, 18);
+        expect(wei).toBe(14285714285714285n);
+    });
+    it("converts $50 to BTC sats at $65,000", () => {
+        // 5000 cents × 10^8 / 6500000 cents = 76923n sats
+        const sats = centsToNative(5000, 6_500_000, 8);
+        expect(sats).toBe(76923n);
+    });
+    it("converts $100 to ETH wei at $2,000", () => {
+        // 10000 cents × 10^18 / 200000 cents = 50000000000000000n wei (0.05 ETH)
+        const wei = centsToNative(10_000, 200_000, 18);
+        expect(wei).toBe(50000000000000000n);
+    });
+    it("rejects non-integer amountCents", () => {
+        expect(() => centsToNative(50.5, 350_000, 18)).toThrow("positive integer");
+    });
+    it("rejects zero amountCents", () => {
+        expect(() => centsToNative(0, 350_000, 18)).toThrow("positive integer");
+    });
+    it("rejects zero priceCents", () => {
+        expect(() => centsToNative(5000, 0, 18)).toThrow("positive integer");
+    });
+    it("rejects negative decimals", () => {
+        expect(() => centsToNative(5000, 350_000, -1)).toThrow("non-negative integer");
+    });
+});
+describe("nativeToCents", () => {
+    it("converts ETH wei back to cents at $3,500", () => {
+        // 14285714285714285n wei × 350000 / 10^18 = 4999 cents (truncated)
+        const cents = nativeToCents(14285714285714285n, 350_000, 18);
+        expect(cents).toBe(4999); // truncation from integer division
+    });
+    it("converts BTC sats back to cents at $65,000", () => {
+        // 76923n sats × 6500000 / 10^8 = 4999 cents (truncated)
+        const cents = nativeToCents(76923n, 6_500_000, 8);
+        expect(cents).toBe(4999);
+    });
+    it("exact round-trip for clean division", () => {
+        // 0.05 ETH at $2,000 = $100
+        const cents = nativeToCents(50000000000000000n, 200_000, 18);
+        expect(cents).toBe(10_000); // $100.00
+    });
+    it("rejects negative rawAmount", () => {
+        expect(() => nativeToCents(-1n, 350_000, 18)).toThrow("non-negative");
+    });
+});

package/dist/billing/crypto/oracle/__tests__/fixed.test.d.ts

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

package/dist/billing/crypto/oracle/__tests__/fixed.test.js

@@ -0,0 +1,20 @@
+import { describe, expect, it } from "vitest";
+import { FixedPriceOracle } from "../fixed.js";
+describe("FixedPriceOracle", () => {
+    it("returns default ETH price", async () => {
+        const oracle = new FixedPriceOracle();
+        const result = await oracle.getPrice("ETH");
+        expect(result.priceCents).toBe(350_000); // $3,500
+        expect(result.updatedAt).toBeInstanceOf(Date);
+    });
+    it("returns default BTC price", async () => {
+        const oracle = new FixedPriceOracle();
+        const result = await oracle.getPrice("BTC");
+        expect(result.priceCents).toBe(6_500_000); // $65,000
+    });
+    it("accepts custom prices", async () => {
+        const oracle = new FixedPriceOracle({ ETH: 200_000, BTC: 5_000_000 });
+        expect((await oracle.getPrice("ETH")).priceCents).toBe(200_000);
+        expect((await oracle.getPrice("BTC")).priceCents).toBe(5_000_000);
+    });
+});

package/dist/billing/crypto/oracle/chainlink.d.ts

@@ -0,0 +1,26 @@
+import type { IPriceOracle, PriceAsset, PriceResult } from "./types.js";
+type RpcCall = (method: string, params: unknown[]) => Promise<unknown>;
+export interface ChainlinkOracleOpts {
+    rpcCall: RpcCall;
+    /** Override feed addresses (e.g. for testnet or Anvil forks). */
+    feedAddresses?: Partial<Record<PriceAsset, `0x${string}`>>;
+    /** Maximum age of price data before rejecting (ms). Default: 1 hour. */
+    maxStalenessMs?: number;
+}
+/**
+ * On-chain Chainlink price oracle.
+ *
+ * Reads latestRoundData() from Chainlink aggregator contracts via eth_call.
+ * No API key, no rate limits — just an RPC call to our own node.
+ *
+ * Chainlink USD feeds use 8 decimals. We convert to integer USD cents:
+ *   priceCents = answer / 10^6  (i.e. answer / 10^8 * 100)
+ */
+export declare class ChainlinkOracle implements IPriceOracle {
+    private readonly rpc;
+    private readonly feeds;
+    private readonly maxStalenessMs;
+    constructor(opts: ChainlinkOracleOpts);
+    getPrice(asset: PriceAsset): Promise<PriceResult>;
+}
+export {};

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

@@ -0,0 +1,61 @@
+/**
+ * Chainlink price feed addresses on Base mainnet.
+ * These are ERC-1967 proxy contracts — addresses are stable.
+ */
+const FEED_ADDRESSES = {
+    ETH: "0x71041dddad3595F9CEd3DcCFBe3D1F4b0a16Bb70",
+    BTC: "0x64c911996D3c6aC71f9b455B1E8E7266BcbD848F",
+};
+/** Function selector for latestRoundData(). */
+const LATEST_ROUND_DATA = "0xfeaf968c";
+/** Default max staleness: 1 hour. */
+const DEFAULT_MAX_STALENESS_MS = 60 * 60 * 1000;
+/**
+ * On-chain Chainlink price oracle.
+ *
+ * Reads latestRoundData() from Chainlink aggregator contracts via eth_call.
+ * No API key, no rate limits — just an RPC call to our own node.
+ *
+ * Chainlink USD feeds use 8 decimals. We convert to integer USD cents:
+ *   priceCents = answer / 10^6  (i.e. answer / 10^8 * 100)
+ */
+export class ChainlinkOracle {
+    rpc;
+    feeds;
+    maxStalenessMs;
+    constructor(opts) {
+        this.rpc = opts.rpcCall;
+        this.feeds = { ...FEED_ADDRESSES, ...opts.feedAddresses };
+        this.maxStalenessMs = opts.maxStalenessMs ?? DEFAULT_MAX_STALENESS_MS;
+    }
+    async getPrice(asset) {
+        const feedAddress = this.feeds[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"]));
+        // ABI decode latestRoundData() return:
+        //   [0]  roundId       (uint80)  — skip
+        //   [1]  answer        (int256)  — price × 10^8
+        //   [2]  startedAt     (uint256) — skip
+        //   [3]  updatedAt     (uint256) — unix seconds
+        //   [4]  answeredInRound (uint80) — skip
+        const hex = result.slice(2);
+        if (hex.length < 320) {
+            throw new Error(`Malformed Chainlink response for ${asset}: expected 320 hex chars, got ${hex.length}`);
+        }
+        const answer = BigInt(`0x${hex.slice(64, 128)}`);
+        const updatedAtSec = Number(BigInt(`0x${hex.slice(192, 256)}`));
+        const updatedAt = new Date(updatedAtSec * 1000);
+        // Staleness guard.
+        const ageMs = Date.now() - updatedAt.getTime();
+        if (ageMs > this.maxStalenessMs) {
+            throw new Error(`Price feed for ${asset} is stale (${Math.round(ageMs / 1000)}s old, max ${Math.round(this.maxStalenessMs / 1000)}s)`);
+        }
+        // Chainlink USD feeds: 8 decimals. answer / 10^6 = cents (integer).
+        const priceCents = Number(answer / 1000000n);
+        if (priceCents <= 0) {
+            throw new Error(`Invalid price for ${asset}: ${priceCents} cents`);
+        }
+        return { priceCents, updatedAt };
+    }
+}

package/dist/billing/crypto/oracle/convert.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Convert USD cents to native token amount using a price in cents.
+ *
+ * Formula: rawAmount = amountCents × 10^decimals / priceCents
+ *
+ * Examples:
+ *   $50 in ETH at $3,500:  centsToNative(5000, 350000, 18) = 14285714285714285n (≈0.01429 ETH)
+ *   $50 in BTC at $65,000: centsToNative(5000, 6500000, 8)  = 76923n (76,923 sats ≈ 0.00077 BTC)
+ *
+ * Integer math only. No floating point.
+ */
+export declare function centsToNative(amountCents: number, priceCents: number, decimals: number): bigint;
+/**
+ * Convert native token amount back to USD cents using a price in cents.
+ *
+ * Inverse of centsToNative. Truncates fractional cents.
+ *
+ * Integer math only.
+ */
+export declare function nativeToCents(rawAmount: bigint, priceCents: number, decimals: number): number;

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

@@ -0,0 +1,38 @@
+/**
+ * Convert USD cents to native token amount using a price in cents.
+ *
+ * Formula: rawAmount = amountCents × 10^decimals / priceCents
+ *
+ * Examples:
+ *   $50 in ETH at $3,500:  centsToNative(5000, 350000, 18) = 14285714285714285n (≈0.01429 ETH)
+ *   $50 in BTC at $65,000: centsToNative(5000, 6500000, 8)  = 76923n (76,923 sats ≈ 0.00077 BTC)
+ *
+ * Integer math only. No floating point.
+ */
+export function centsToNative(amountCents, priceCents, decimals) {
+    if (!Number.isInteger(amountCents) || amountCents <= 0) {
+        throw new Error(`amountCents must be a positive integer, got ${amountCents}`);
+    }
+    if (!Number.isInteger(priceCents) || priceCents <= 0) {
+        throw new Error(`priceCents must be a positive integer, got ${priceCents}`);
+    }
+    if (!Number.isInteger(decimals) || decimals < 0) {
+        throw new Error(`decimals must be a non-negative integer, got ${decimals}`);
+    }
+    return (BigInt(amountCents) * 10n ** BigInt(decimals)) / BigInt(priceCents);
+}
+/**
+ * Convert native token amount back to USD cents using a price in cents.
+ *
+ * Inverse of centsToNative. Truncates fractional cents.
+ *
+ * Integer math only.
+ */
+export function nativeToCents(rawAmount, priceCents, decimals) {
+    if (rawAmount < 0n)
+        throw new Error("rawAmount must be non-negative");
+    if (!Number.isInteger(priceCents) || priceCents <= 0) {
+        throw new Error(`priceCents must be a positive integer, got ${priceCents}`);
+    }
+    return Number((rawAmount * BigInt(priceCents)) / 10n ** BigInt(decimals));
+}

package/dist/billing/crypto/oracle/fixed.d.ts

@@ -0,0 +1,10 @@
+import type { IPriceOracle, PriceAsset, PriceResult } from "./types.js";
+/**
+ * Fixed-price oracle for testing and local dev (Anvil, regtest).
+ * Returns hardcoded prices — no RPC calls.
+ */
+export declare class FixedPriceOracle implements IPriceOracle {
+    private readonly prices;
+    constructor(prices?: Partial<Record<PriceAsset, number>>);
+    getPrice(asset: PriceAsset): Promise<PriceResult>;
+}

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

@@ -0,0 +1,20 @@
+/**
+ * Fixed-price oracle for testing and local dev (Anvil, regtest).
+ * Returns hardcoded prices — no RPC calls.
+ */
+export class FixedPriceOracle {
+    prices;
+    constructor(prices = {}) {
+        this.prices = {
+            ETH: 350_000, // $3,500
+            BTC: 6_500_000, // $65,000
+            ...prices,
+        };
+    }
+    async getPrice(asset) {
+        const priceCents = this.prices[asset];
+        if (priceCents === undefined)
+            throw new Error(`No fixed price for ${asset}`);
+        return { priceCents, updatedAt: new Date() };
+    }
+}

package/dist/billing/crypto/oracle/index.d.ts

@@ -0,0 +1,5 @@
+export type { ChainlinkOracleOpts } from "./chainlink.js";
+export { ChainlinkOracle } from "./chainlink.js";
+export { centsToNative, nativeToCents } from "./convert.js";
+export { FixedPriceOracle } from "./fixed.js";
+export type { IPriceOracle, PriceAsset, PriceResult } from "./types.js";

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

@@ -0,0 +1,3 @@
+export { ChainlinkOracle } from "./chainlink.js";
+export { centsToNative, nativeToCents } from "./convert.js";
+export { FixedPriceOracle } from "./fixed.js";

package/dist/billing/crypto/oracle/types.d.ts

@@ -0,0 +1,13 @@
+/** Assets with Chainlink price feeds. */
+export type PriceAsset = "ETH" | "BTC";
+/** Result from a price oracle query. */
+export interface PriceResult {
+    /** USD cents per 1 unit of asset (integer). */
+    priceCents: number;
+    /** When the price was last updated on-chain. */
+    updatedAt: Date;
+}
+/** Read-only price oracle. */
+export interface IPriceOracle {
+    getPrice(asset: PriceAsset): Promise<PriceResult>;
+}

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

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

package/package.json

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

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

@@ -28,7 +28,7 @@ export async function settleBtcPayment(deps: BtcSettlerDeps, event: BtcPaymentEv
 
   const charge = await chargeStore.getByDepositAddress(event.address);
   if (!charge) {
-    return { handled: false, status: "Settled" };
+    return { handled: false, status: "Invalid" };
   }
 
   await chargeStore.updateStatus(charge.referenceId, "Settled");

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

@@ -1,3 +1,4 @@
+import type { IPriceOracle } from "../oracle/types.js";
 import type { BitcoindConfig, BtcPaymentEvent } from "./types.js";
 
 type RpcCall = (method: string, params: unknown[]) => Promise<unknown>;
@@ -8,8 +9,8 @@ export interface BtcWatcherOpts {
   /** Addresses to watch (must be imported into bitcoind wallet first). */
   watchedAddresses: string[];
   onPayment: (event: BtcPaymentEvent) => void | Promise<void>;
-  /** Current BTC/USD price for conversion. */
-  getBtcPrice: () => Promise<number>;
+  /** Price oracle for BTC/USD conversion. */
+  oracle: IPriceOracle;
 }
 
 interface ReceivedByAddress {
@@ -19,22 +20,20 @@ interface ReceivedByAddress {
   txids: string[];
 }
 
-/** Track which txids we've already processed to avoid double-crediting. */
-const processedTxids = new Set<string>();
-
 export class BtcWatcher {
   private readonly rpc: RpcCall;
   private readonly addresses: Set<string>;
   private readonly onPayment: BtcWatcherOpts["onPayment"];
   private readonly minConfirmations: number;
-  private readonly getBtcPrice: () => Promise<number>;
+  private readonly oracle: IPriceOracle;
+  private readonly processedTxids = new Set<string>();
 
   constructor(opts: BtcWatcherOpts) {
     this.rpc = opts.rpcCall;
     this.addresses = new Set(opts.watchedAddresses);
     this.onPayment = opts.onPayment;
     this.minConfirmations = opts.config.confirmations;
-    this.getBtcPrice = opts.getBtcPrice;
+    this.oracle = opts.oracle;
   }
 
   /** Update the set of watched addresses. */
@@ -59,14 +58,13 @@ export class BtcWatcher {
       true, // include_watchonly
     ])) as ReceivedByAddress[];
 
-    const btcPrice = await this.getBtcPrice();
+    const { priceCents } = await this.oracle.getPrice("BTC");
 
     for (const entry of received) {
       if (!this.addresses.has(entry.address)) continue;
 
       for (const txid of entry.txids) {
-        if (processedTxids.has(txid)) continue;
-        processedTxids.add(txid);
+        if (this.processedTxids.has(txid)) continue;
 
         // Get transaction details for the exact amount sent to this address
         const tx = (await this.rpc("gettransaction", [txid, true])) as {
@@ -78,7 +76,8 @@ export class BtcWatcher {
         if (!detail) continue;
 
         const amountSats = Math.round(detail.amount * 100_000_000);
-        const amountUsdCents = Math.round(detail.amount * btcPrice * 100);
+        // priceCents is cents per 1 BTC. detail.amount is in BTC.
+        const amountUsdCents = Math.round((amountSats * priceCents) / 100_000_000);
 
         const event: BtcPaymentEvent = {
           address: entry.address,
@@ -89,6 +88,8 @@ export class BtcWatcher {
         };
 
         await this.onPayment(event);
+        // Add AFTER successful onPayment to avoid skipping on failure
+        this.processedTxids.add(txid);
       }
     }
   }

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

@@ -0,0 +1,60 @@
+import { describe, expect, it, vi } from "vitest";
+import { createEthCheckout, MIN_ETH_USD } from "../eth-checkout.js";
+
+const mockOracle = { getPrice: vi.fn().mockResolvedValue({ priceCents: 350_000, updatedAt: new Date() }) };
+
+function makeDeps(derivationIndex = 0) {
+  return {
+    chargeStore: {
+      getNextDerivationIndex: vi.fn().mockResolvedValue(derivationIndex),
+      createStablecoinCharge: vi.fn().mockResolvedValue(undefined),
+    },
+    oracle: mockOracle,
+    xpub: "xpub661MyMwAqRbcFtXgS5sYJABqqG9YLmC4Q1Rdap9gSE8NqtwybGhePY2gZ29ESFjqJoCu1Rupje8YtGqsefD265TMg7usUDFdp6W1EGMcet8",
+  };
+}
+
+describe("createEthCheckout", () => {
+  it("creates checkout with oracle-derived expected wei", async () => {
+    const deps = makeDeps();
+    const result = await createEthCheckout(deps, { tenant: "t1", amountUsd: 50, chain: "base" });
+
+    expect(result.amountUsd).toBe(50);
+    expect(result.priceCents).toBe(350_000);
+    expect(result.chain).toBe("base");
+    // $50 = 5000 cents. 5000 × 10^18 / 350000 = 14285714285714285n
+    expect(result.expectedWei).toBe("14285714285714285");
+    expect(result.depositAddress).toMatch(/^0x/);
+    expect(result.referenceId).toMatch(/^eth:base:0x/);
+  });
+
+  it("rejects amount below minimum", async () => {
+    const deps = makeDeps();
+    await expect(createEthCheckout(deps, { tenant: "t1", amountUsd: 5, chain: "base" })).rejects.toThrow(
+      `Minimum payment amount is $${MIN_ETH_USD}`,
+    );
+  });
+
+  it("retries on unique constraint violation", async () => {
+    const deps = makeDeps();
+    deps.chargeStore.createStablecoinCharge
+      .mockRejectedValueOnce(Object.assign(new Error("unique_violation"), { code: "23505" }))
+      .mockResolvedValueOnce(undefined);
+    deps.chargeStore.getNextDerivationIndex.mockResolvedValueOnce(0).mockResolvedValueOnce(1);
+
+    const result = await createEthCheckout(deps, { tenant: "t1", amountUsd: 50, chain: "base" });
+    expect(result.depositAddress).toMatch(/^0x/);
+    expect(deps.chargeStore.createStablecoinCharge).toHaveBeenCalledTimes(2);
+  });
+
+  it("stores amountUsdCents as integer cents", async () => {
+    const deps = makeDeps();
+    await createEthCheckout(deps, { tenant: "t1", amountUsd: 50, chain: "base" });
+
+    const call = deps.chargeStore.createStablecoinCharge.mock.calls[0][0];
+    expect(call.amountUsdCents).toBe(5000);
+    expect(Number.isInteger(call.amountUsdCents)).toBe(true);
+    expect(call.token).toBe("ETH");
+    expect(call.chain).toBe("base");
+  });
+});