@wopr-network/platform-core 1.67.0 → 1.67.1

package/dist/billing/crypto/btc/watcher.js

@@ -1,118 +0,0 @@
-import { nativeToCents } from "../oracle/convert.js";
-export class BtcWatcher {
-    rpc;
-    addresses;
-    onPayment;
-    minConfirmations;
-    oracle;
-    cursorStore;
-    watcherId;
-    constructor(opts) {
-        this.rpc = opts.rpcCall;
-        this.addresses = new Set(opts.watchedAddresses);
-        this.onPayment = opts.onPayment;
-        this.minConfirmations = opts.config.confirmations;
-        this.oracle = opts.oracle;
-        this.cursorStore = opts.cursorStore;
-        this.watcherId = `btc:${opts.chainId ?? opts.config.network}`;
-    }
-    /** Update the set of watched addresses. */
-    setWatchedAddresses(addresses) {
-        this.addresses.clear();
-        for (const a of addresses)
-            this.addresses.add(a);
-    }
-    /**
-     * Import an address into bitcoind's wallet (watch-only).
-     * Uses `importdescriptors` (modern bitcoind v24+) with fallback to legacy `importaddress`.
-     */
-    async importAddress(address) {
-        try {
-            // Modern bitcoind: get descriptor checksum, then import
-            const info = (await this.rpc("getdescriptorinfo", [`addr(${address})`]));
-            const result = (await this.rpc("importdescriptors", [[{ desc: info.descriptor, timestamp: 0 }]]));
-            if (result[0] && !result[0].success) {
-                throw new Error(result[0].error?.message ?? "importdescriptors failed");
-            }
-        }
-        catch {
-            // Fallback: legacy importaddress (bitcoind <v24)
-            await this.rpc("importaddress", [address, "", false]);
-        }
-        this.addresses.add(address);
-    }
-    /**
-     * Poll for payments to watched addresses, including unconfirmed txs.
-     *
-     * Fires onPayment on every confirmation increment (0, 1, 2, ... threshold).
-     * Only marks a tx as fully processed once it reaches the confirmation threshold.
-     */
-    async poll() {
-        if (this.addresses.size === 0)
-            return;
-        // Poll with minconf=0 to see unconfirmed txs
-        const received = (await this.rpc("listreceivedbyaddress", [
-            0, // minconf=0: see ALL txs including unconfirmed
-            false, // include_empty
-            true, // include_watchonly
-        ]));
-        const { priceMicros } = await this.oracle.getPrice("BTC");
-        for (const entry of received) {
-            if (!this.addresses.has(entry.address))
-                continue;
-            for (const txid of entry.txids) {
-                // Skip fully-processed txids (already reached threshold, persisted to DB)
-                if (await this.cursorStore.hasProcessedTx(this.watcherId, txid))
-                    continue;
-                // Get transaction details for the exact amount sent to this address
-                const tx = (await this.rpc("gettransaction", [txid, true]));
-                const detail = tx.details.find((d) => d.address === entry.address && d.category === "receive");
-                if (!detail)
-                    continue;
-                // Check if confirmations have increased since last seen
-                const lastSeen = await this.cursorStore.getConfirmationCount(this.watcherId, txid);
-                if (lastSeen !== null && tx.confirmations <= lastSeen)
-                    continue; // No change
-                const amountSats = Math.round(detail.amount * 100_000_000);
-                // priceMicros is microdollars per 1 BTC. Convert sats→USD cents via nativeToCents.
-                const amountUsdCents = nativeToCents(BigInt(amountSats), priceMicros, 8);
-                const event = {
-                    address: entry.address,
-                    txid,
-                    amountSats,
-                    amountUsdCents,
-                    confirmations: tx.confirmations,
-                    confirmationsRequired: this.minConfirmations,
-                };
-                await this.onPayment(event);
-                // Persist confirmation count
-                await this.cursorStore.saveConfirmationCount(this.watcherId, txid, tx.confirmations);
-                // Mark as fully processed once we reach the threshold
-                if (tx.confirmations >= this.minConfirmations) {
-                    await this.cursorStore.markProcessedTx(this.watcherId, txid);
-                }
-            }
-        }
-    }
-}
-/** Create a bitcoind JSON-RPC caller with basic auth. */
-export function createBitcoindRpc(config) {
-    let id = 0;
-    const auth = btoa(`${config.rpcUser}:${config.rpcPassword}`);
-    return async (method, params) => {
-        const res = await fetch(config.rpcUrl, {
-            method: "POST",
-            headers: {
-                "Content-Type": "application/json",
-                Authorization: `Basic ${auth}`,
-            },
-            body: JSON.stringify({ jsonrpc: "1.0", id: ++id, method, params }),
-        });
-        if (!res.ok)
-            throw new Error(`bitcoind ${method} failed: ${res.status}`);
-        const data = (await res.json());
-        if (data.error)
-            throw new Error(`bitcoind ${method}: ${data.error.message}`);
-        return data.result;
-    };
-}

package/dist/billing/crypto/evm/__tests__/eth-watcher.test.d.ts

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

package/dist/billing/crypto/evm/__tests__/eth-watcher.test.js

@@ -1,167 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { EthWatcher } from "../eth-watcher.js";
-function makeRpc(responses) {
-    return vi.fn(async (method) => responses[method]);
-}
-const mockOracle = { getPrice: vi.fn().mockResolvedValue({ priceMicros: 3_500_000_000, updatedAt: new Date() }) };
-describe("EthWatcher", () => {
-    it("detects native ETH transfer to watched address", async () => {
-        const onPayment = vi.fn();
-        // latest = 0xa (10), fromBlock = 10 → scans exactly block 10
-        const rpc = makeRpc({
-            eth_blockNumber: "0xa",
-            eth_getBlockByNumber: {
-                transactions: [
-                    {
-                        hash: "0xabc",
-                        from: "0xsender",
-                        to: "0xdeposit",
-                        value: "0xDE0B6B3A7640000", // 1 ETH = 10^18 wei
-                        blockNumber: "0xa",
-                    },
-                ],
-            },
-        });
-        const watcher = new EthWatcher({
-            chain: "base",
-            rpcCall: rpc,
-            oracle: mockOracle,
-            fromBlock: 10,
-            confirmations: 1,
-            onPayment,
-            watchedAddresses: ["0xDeposit"],
-        });
-        await watcher.poll();
-        expect(onPayment).toHaveBeenCalledOnce();
-        const event = onPayment.mock.calls[0][0];
-        expect(event.to).toBe("0xdeposit");
-        expect(event.valueWei).toBe("1000000000000000000");
-        expect(event.amountUsdCents).toBe(350_000); // 1 ETH × $3,500 = $3,500 = 350,000 cents
-        expect(event.txHash).toBe("0xabc");
-        expect(event.confirmations).toBe(0);
-        expect(event.confirmationsRequired).toBe(1);
-    });
-    it("skips transactions not to watched addresses", async () => {
-        const onPayment = vi.fn();
-        const rpc = makeRpc({
-            eth_blockNumber: "0xb",
-            eth_getBlockByNumber: {
-                transactions: [{ hash: "0xabc", from: "0xa", to: "0xother", value: "0xDE0B6B3A7640000", blockNumber: "0xa" }],
-            },
-        });
-        const watcher = new EthWatcher({
-            chain: "base",
-            rpcCall: rpc,
-            oracle: mockOracle,
-            fromBlock: 10,
-            confirmations: 1,
-            onPayment,
-            watchedAddresses: ["0xDeposit"],
-        });
-        await watcher.poll();
-        expect(onPayment).not.toHaveBeenCalled();
-    });
-    it("skips zero-value transactions", async () => {
-        const onPayment = vi.fn();
-        const rpc = makeRpc({
-            eth_blockNumber: "0xb",
-            eth_getBlockByNumber: {
-                transactions: [{ hash: "0xabc", from: "0xa", to: "0xdeposit", value: "0x0", blockNumber: "0xa" }],
-            },
-        });
-        const watcher = new EthWatcher({
-            chain: "base",
-            rpcCall: rpc,
-            oracle: mockOracle,
-            fromBlock: 10,
-            confirmations: 1,
-            onPayment,
-            watchedAddresses: ["0xDeposit"],
-        });
-        await watcher.poll();
-        expect(onPayment).not.toHaveBeenCalled();
-    });
-    it("does not double-process same txid", async () => {
-        const onPayment = vi.fn();
-        const confirmations = new Map();
-        const cursorStore = {
-            get: vi.fn().mockResolvedValue(null),
-            save: vi.fn().mockResolvedValue(undefined),
-            hasProcessedTx: vi.fn().mockResolvedValue(false),
-            markProcessedTx: vi.fn().mockResolvedValue(undefined),
-            getConfirmationCount: vi
-                .fn()
-                .mockImplementation(async (_, txId) => confirmations.get(txId) ?? null),
-            saveConfirmationCount: vi.fn().mockImplementation(async (_, txId, count) => {
-                confirmations.set(txId, count);
-            }),
-        };
-        const rpc = makeRpc({
-            eth_blockNumber: "0xb",
-            eth_getBlockByNumber: {
-                transactions: [{ hash: "0xabc", from: "0xa", to: "0xdeposit", value: "0xDE0B6B3A7640000", blockNumber: "0xa" }],
-            },
-        });
-        const watcher = new EthWatcher({
-            chain: "base",
-            rpcCall: rpc,
-            oracle: mockOracle,
-            fromBlock: 10,
-            confirmations: 1,
-            onPayment,
-            watchedAddresses: ["0xDeposit"],
-            cursorStore,
-        });
-        await watcher.poll();
-        // Second poll — same block, same confirmations → no duplicate emission
-        await watcher.poll();
-        expect(onPayment).toHaveBeenCalledOnce();
-    });
-    it("skips poll when no watched addresses", async () => {
-        const onPayment = vi.fn();
-        const rpc = vi.fn();
-        const watcher = new EthWatcher({
-            chain: "base",
-            rpcCall: rpc,
-            oracle: mockOracle,
-            fromBlock: 10,
-            confirmations: 1,
-            onPayment,
-            watchedAddresses: [],
-        });
-        await watcher.poll();
-        expect(rpc).not.toHaveBeenCalled();
-    });
-    it("does not mark txid as processed if onPayment throws", async () => {
-        const onPayment = vi.fn().mockRejectedValueOnce(new Error("db fail")).mockResolvedValueOnce(undefined);
-        const cursorStore = {
-            get: vi.fn().mockResolvedValue(null),
-            save: vi.fn().mockResolvedValue(undefined),
-            hasProcessedTx: vi.fn().mockResolvedValue(false),
-            markProcessedTx: vi.fn().mockResolvedValue(undefined),
-            getConfirmationCount: vi.fn().mockResolvedValue(null),
-            saveConfirmationCount: vi.fn().mockResolvedValue(undefined),
-        };
-        // latest = 0xa (10) = fromBlock → exactly one block to scan
-        const rpc = makeRpc({
-            eth_blockNumber: "0xa",
-            eth_getBlockByNumber: {
-                transactions: [{ hash: "0xabc", from: "0xa", to: "0xdeposit", value: "0xDE0B6B3A7640000", blockNumber: "0xa" }],
-            },
-        });
-        const watcher = new EthWatcher({
-            chain: "base",
-            rpcCall: rpc,
-            oracle: mockOracle,
-            fromBlock: 10,
-            confirmations: 1,
-            onPayment,
-            watchedAddresses: ["0xDeposit"],
-            cursorStore,
-        });
-        await expect(watcher.poll()).rejects.toThrow("db fail");
-        // Retry — should process the same tx again since confirmationCount wasn't saved (error before save)
-        await watcher.poll();
-        expect(onPayment).toHaveBeenCalledTimes(2);
-    });
-});

package/dist/billing/crypto/evm/__tests__/watcher-confirmations.test.d.ts

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

package/dist/billing/crypto/evm/__tests__/watcher-confirmations.test.js

@@ -1,159 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { EvmWatcher } from "../watcher.js";
-const TRANSFER_TOPIC = "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef";
-function mockTransferLog(to, amount, blockNumber) {
-    return {
-        address: "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
-        topics: [
-            TRANSFER_TOPIC,
-            `0x${"00".repeat(12)}${"ab".repeat(20)}`,
-            `0x${"00".repeat(12)}${to.slice(2).toLowerCase()}`,
-        ],
-        data: `0x${amount.toString(16).padStart(64, "0")}`,
-        blockNumber: `0x${blockNumber.toString(16)}`,
-        transactionHash: `0x${"ff".repeat(32)}`,
-        logIndex: "0x0",
-    };
-}
-function makeCursorStore() {
-    const cursors = new Map();
-    return {
-        get: vi.fn().mockImplementation(async (id) => cursors.get(id) ?? null),
-        save: vi.fn().mockImplementation(async (id, val) => {
-            cursors.set(id, val);
-        }),
-        hasProcessedTx: vi.fn().mockResolvedValue(false),
-        markProcessedTx: vi.fn().mockResolvedValue(undefined),
-        getConfirmationCount: vi.fn().mockResolvedValue(null),
-        saveConfirmationCount: vi.fn().mockResolvedValue(undefined),
-    };
-}
-describe("EvmWatcher — intermediate confirmations", () => {
-    it("emits events with confirmation count", async () => {
-        const toAddr = `0x${"cc".repeat(20)}`;
-        const events = [];
-        // Base has confirmations: 1. Latest block is 105. Log at block 103 -> 2 confirmations.
-        const mockRpc = vi
-            .fn()
-            .mockResolvedValueOnce(`0x${(105).toString(16)}`) // eth_blockNumber
-            .mockResolvedValueOnce([mockTransferLog(toAddr, 10000000n, 103)]); // eth_getLogs
-        const watcher = new EvmWatcher({
-            chain: "base",
-            token: "USDC",
-            contractAddress: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
-            decimals: 6,
-            confirmations: 1,
-            rpcCall: mockRpc,
-            fromBlock: 100,
-            watchedAddresses: [toAddr],
-            cursorStore: makeCursorStore(),
-            onPayment: (evt) => {
-                events.push(evt);
-            },
-        });
-        await watcher.poll();
-        expect(events).toHaveLength(1);
-        expect(events[0].confirmations).toBe(2); // 105 - 103
-        expect(events[0].confirmationsRequired).toBe(1); // Base chain config
-    });
-    it("skips event when confirmation count unchanged", async () => {
-        const toAddr = `0x${"cc".repeat(20)}`;
-        const events = [];
-        const cursorStore = makeCursorStore();
-        cursorStore.getConfirmationCount.mockResolvedValue(2);
-        const mockRpc = vi
-            .fn()
-            .mockResolvedValueOnce(`0x${(105).toString(16)}`)
-            .mockResolvedValueOnce([mockTransferLog(toAddr, 10000000n, 103)]);
-        const watcher = new EvmWatcher({
-            chain: "base",
-            token: "USDC",
-            contractAddress: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
-            decimals: 6,
-            confirmations: 1,
-            rpcCall: mockRpc,
-            fromBlock: 100,
-            watchedAddresses: [toAddr],
-            cursorStore,
-            onPayment: (evt) => {
-                events.push(evt);
-            },
-        });
-        await watcher.poll();
-        expect(events).toHaveLength(0);
-    });
-    it("re-emits when confirmations increase", async () => {
-        const toAddr = `0x${"cc".repeat(20)}`;
-        const events = [];
-        const cursorStore = makeCursorStore();
-        cursorStore.getConfirmationCount.mockResolvedValue(1);
-        const mockRpc = vi
-            .fn()
-            .mockResolvedValueOnce(`0x${(105).toString(16)}`)
-            .mockResolvedValueOnce([mockTransferLog(toAddr, 10000000n, 103)]);
-        const watcher = new EvmWatcher({
-            chain: "base",
-            token: "USDC",
-            contractAddress: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
-            decimals: 6,
-            confirmations: 1,
-            rpcCall: mockRpc,
-            fromBlock: 100,
-            watchedAddresses: [toAddr],
-            cursorStore,
-            onPayment: (evt) => {
-                events.push(evt);
-            },
-        });
-        await watcher.poll();
-        expect(events).toHaveLength(1);
-        expect(events[0].confirmations).toBe(2);
-    });
-    it("includes confirmationsRequired from chain config", async () => {
-        const toAddr = `0x${"cc".repeat(20)}`;
-        const events = [];
-        const mockRpc = vi
-            .fn()
-            .mockResolvedValueOnce(`0x${(110).toString(16)}`)
-            .mockResolvedValueOnce([mockTransferLog(toAddr, 10000000n, 105)]);
-        const watcher = new EvmWatcher({
-            chain: "base",
-            token: "USDC",
-            contractAddress: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
-            decimals: 6,
-            confirmations: 1,
-            rpcCall: mockRpc,
-            fromBlock: 100,
-            watchedAddresses: [toAddr],
-            cursorStore: makeCursorStore(),
-            onPayment: (evt) => {
-                events.push(evt);
-            },
-        });
-        await watcher.poll();
-        expect(events).toHaveLength(1);
-        expect(events[0].confirmationsRequired).toBe(1); // Base chain config
-    });
-    it("saves confirmation count after emitting", async () => {
-        const toAddr = `0x${"cc".repeat(20)}`;
-        const cursorStore = makeCursorStore();
-        const mockRpc = vi
-            .fn()
-            .mockResolvedValueOnce(`0x${(105).toString(16)}`)
-            .mockResolvedValueOnce([mockTransferLog(toAddr, 10000000n, 103)]);
-        const watcher = new EvmWatcher({
-            chain: "base",
-            token: "USDC",
-            contractAddress: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
-            decimals: 6,
-            confirmations: 1,
-            rpcCall: mockRpc,
-            fromBlock: 100,
-            watchedAddresses: [toAddr],
-            cursorStore,
-            onPayment: () => { },
-        });
-        await watcher.poll();
-        expect(cursorStore.saveConfirmationCount).toHaveBeenCalledWith(expect.any(String), expect.stringContaining("0x"), 2);
-    });
-});

package/dist/billing/crypto/evm/__tests__/watcher.test.d.ts

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

package/dist/billing/crypto/evm/__tests__/watcher.test.js

@@ -1,145 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { EvmWatcher } from "../watcher.js";
-const TRANSFER_TOPIC = "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef";
-function mockTransferLog(to, amount, blockNumber) {
-    return {
-        address: "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
-        topics: [
-            TRANSFER_TOPIC,
-            `0x${"00".repeat(12)}${"ab".repeat(20)}`, // from (padded)
-            `0x${"00".repeat(12)}${to.slice(2).toLowerCase()}`, // to (padded)
-        ],
-        data: `0x${amount.toString(16).padStart(64, "0")}`,
-        blockNumber: `0x${blockNumber.toString(16)}`,
-        transactionHash: `0x${"ff".repeat(32)}`,
-        logIndex: "0x0",
-    };
-}
-describe("EvmWatcher", () => {
-    it("parses Transfer log into EvmPaymentEvent", async () => {
-        const toAddr = `0x${"cc".repeat(20)}`;
-        const events = [];
-        const mockRpc = vi
-            .fn()
-            .mockResolvedValueOnce(`0x${(102).toString(16)}`)
-            .mockResolvedValueOnce([mockTransferLog(toAddr, 10000000n, 99)]);
-        const watcher = new EvmWatcher({
-            chain: "base",
-            token: "USDC",
-            contractAddress: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
-            decimals: 6,
-            confirmations: 1,
-            rpcCall: mockRpc,
-            fromBlock: 99,
-            watchedAddresses: [toAddr],
-            onPayment: (evt) => {
-                events.push(evt);
-            },
-        });
-        await watcher.poll();
-        expect(events).toHaveLength(1);
-        expect(events[0].amountUsdCents).toBe(1000);
-        expect(events[0].to).toMatch(/^0x/);
-    });
-    it("advances cursor after processing", async () => {
-        const mockRpc = vi
-            .fn()
-            .mockResolvedValueOnce(`0x${(200).toString(16)}`)
-            .mockResolvedValueOnce([]);
-        const watcher = new EvmWatcher({
-            chain: "base",
-            token: "USDC",
-            contractAddress: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
-            decimals: 6,
-            confirmations: 1,
-            rpcCall: mockRpc,
-            fromBlock: 100,
-            watchedAddresses: ["0xdeadbeef"],
-            onPayment: vi.fn(),
-        });
-        await watcher.poll();
-        expect(watcher.cursor).toBeGreaterThan(100);
-    });
-    it("skips blocks not yet confirmed", async () => {
-        const events = [];
-        // latest = 50, cursor = 50 → latest < cursor is false, but range is empty (50..50)
-        // With intermediate confirmations, we still scan the range but find no logs
-        const mockRpc = vi
-            .fn()
-            .mockResolvedValueOnce(`0x${(50).toString(16)}`) // eth_blockNumber
-            .mockResolvedValueOnce([]); // eth_getLogs (empty)
-        const watcher = new EvmWatcher({
-            chain: "base",
-            token: "USDC",
-            contractAddress: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
-            decimals: 6,
-            confirmations: 1,
-            rpcCall: mockRpc,
-            fromBlock: 50,
-            watchedAddresses: ["0xdeadbeef"],
-            onPayment: (evt) => {
-                events.push(evt);
-            },
-        });
-        await watcher.poll();
-        expect(events).toHaveLength(0);
-    });
-    it("processes multiple logs in one poll", async () => {
-        const addr1 = `0x${"aa".repeat(20)}`;
-        const addr2 = `0x${"bb".repeat(20)}`;
-        const events = [];
-        const mockRpc = vi
-            .fn()
-            .mockResolvedValueOnce(`0x${(110).toString(16)}`)
-            .mockResolvedValueOnce([mockTransferLog(addr1, 5000000n, 105), mockTransferLog(addr2, 20000000n, 107)]);
-        const watcher = new EvmWatcher({
-            chain: "base",
-            token: "USDC",
-            contractAddress: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
-            decimals: 6,
-            confirmations: 1,
-            rpcCall: mockRpc,
-            fromBlock: 100,
-            watchedAddresses: [addr1, addr2],
-            onPayment: (evt) => {
-                events.push(evt);
-            },
-        });
-        await watcher.poll();
-        expect(events).toHaveLength(2);
-        expect(events[0].amountUsdCents).toBe(500);
-        expect(events[1].amountUsdCents).toBe(2000);
-    });
-    it("does nothing when no new blocks", async () => {
-        const mockRpc = vi.fn().mockResolvedValueOnce(`0x${(99).toString(16)}`);
-        const watcher = new EvmWatcher({
-            chain: "base",
-            token: "USDC",
-            contractAddress: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
-            decimals: 6,
-            confirmations: 1,
-            rpcCall: mockRpc,
-            fromBlock: 100,
-            watchedAddresses: ["0xdeadbeef"],
-            onPayment: vi.fn(),
-        });
-        await watcher.poll();
-        expect(watcher.cursor).toBe(100);
-        expect(mockRpc).toHaveBeenCalledTimes(1);
-    });
-    it("early-returns when no watched addresses are set", async () => {
-        const mockRpc = vi.fn();
-        const watcher = new EvmWatcher({
-            chain: "base",
-            token: "USDC",
-            contractAddress: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
-            decimals: 6,
-            confirmations: 1,
-            rpcCall: mockRpc,
-            fromBlock: 0,
-            onPayment: vi.fn(),
-        });
-        await watcher.poll();
-        expect(mockRpc).not.toHaveBeenCalled(); // no RPC calls at all
-    });
-});

package/dist/billing/crypto/evm/eth-watcher.d.ts

@@ -1,66 +0,0 @@
-import type { IWatcherCursorStore } from "../cursor-store.js";
-import type { IPriceOracle } from "../oracle/types.js";
-import type { EvmChain } from "./types.js";
-type RpcCall = (method: string, params: unknown[]) => Promise<unknown>;
-/** Event emitted on each confirmation increment for a native ETH deposit. */
-export interface EthPaymentEvent {
-    readonly chain: EvmChain;
-    readonly from: string;
-    readonly to: string;
-    /** Raw value in wei (BigInt as string for serialization). */
-    readonly valueWei: string;
-    /** USD cents equivalent at detection time (integer). */
-    readonly amountUsdCents: number;
-    readonly txHash: string;
-    readonly blockNumber: number;
-    /** Current confirmation count (latest block - tx block). */
-    readonly confirmations: number;
-    /** Required confirmations for this chain. */
-    readonly confirmationsRequired: number;
-}
-export interface EthWatcherOpts {
-    chain: EvmChain;
-    rpcCall: RpcCall;
-    oracle: IPriceOracle;
-    fromBlock: number;
-    onPayment: (event: EthPaymentEvent) => void | Promise<void>;
-    watchedAddresses?: string[];
-    cursorStore?: IWatcherCursorStore;
-    /** Required confirmations (from DB). */
-    confirmations: number;
-}
-/**
- * Native ETH transfer watcher.
- *
- * Unlike the ERC-20 EvmWatcher which uses eth_getLogs for Transfer events,
- * this scans blocks for transactions where `to` matches a watched deposit
- * address and `value > 0`.
- *
- * Scans up to latest block (not just confirmed) to detect pending txs.
- * Emits events on each confirmation increment. Only advances cursor
- * past fully-confirmed blocks.
- */
-export declare class EthWatcher {
-    private _cursor;
-    private readonly chain;
-    private readonly rpc;
-    private readonly oracle;
-    private readonly onPayment;
-    private readonly confirmations;
-    private readonly cursorStore?;
-    private readonly watcherId;
-    private _watchedAddresses;
-    constructor(opts: EthWatcherOpts);
-    /** Load cursor from DB. Call once at startup before first poll. */
-    init(): Promise<void>;
-    setWatchedAddresses(addresses: string[]): void;
-    get cursor(): number;
-    /**
-     * Poll for native ETH transfers to watched addresses, including unconfirmed blocks.
-     *
-     * Scans from cursor to latest block. Emits events with current confirmation count.
-     * Re-emits on each confirmation increment. Only advances cursor past fully-confirmed blocks.
-     */
-    poll(): Promise<void>;
-}
-export {};