@wopr-network/crypto-plugins 1.0.1

package/src/evm/eth-watcher.ts

@@ -0,0 +1,168 @@
+import type {
+	IChainWatcher,
+	IPriceOracle,
+	IWatcherCursorStore,
+	PaymentEvent,
+	WatcherOpts,
+} from "@wopr-network/platform-core/crypto-plugin";
+import type { RpcCall, RpcTransaction } from "./types.js";
+import { createRpcCaller } from "./watcher.js";
+
+/** Microdollars per cent. Used for oracle price conversion. */
+const MICROS_PER_CENT = 10_000n;
+
+/**
+ * Convert native token amount to USD cents using oracle price in microdollars.
+ *
+ * @param rawAmount - Raw value in smallest unit (e.g. wei)
+ * @param priceMicros - Price per whole token in microdollars (10^-6 USD)
+ * @param decimals - Token decimals (18 for ETH)
+ */
+function nativeToCents(rawAmount: bigint, priceMicros: number, decimals: number): number {
+	if (rawAmount < 0n) throw new Error("rawAmount must be non-negative");
+	if (!Number.isInteger(priceMicros) || priceMicros <= 0) {
+		throw new Error(`priceMicros must be a positive integer, got ${priceMicros}`);
+	}
+	return Number((rawAmount * BigInt(priceMicros)) / (MICROS_PER_CENT * 10n ** BigInt(decimals)));
+}
+
+/**
+ * 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 class EthWatcher implements IChainWatcher {
+	private _cursor = 0;
+	private _stopped = false;
+	private readonly chain: string;
+	private readonly token: string;
+	private readonly rpc: RpcCall;
+	private readonly oracle: IPriceOracle;
+	private readonly confirmations: number;
+	private readonly cursorStore: IWatcherCursorStore;
+	private readonly watcherId: string;
+	private _watchedAddresses: Set<string>;
+
+	constructor(opts: WatcherOpts) {
+		this.chain = opts.chain;
+		this.token = opts.token;
+		this.rpc = createRpcCaller(opts.rpcUrl, opts.rpcHeaders);
+		this.oracle = opts.oracle;
+		this._cursor = 0;
+		this.confirmations = opts.confirmations;
+		this.cursorStore = opts.cursorStore;
+		this.watcherId = `eth:${opts.chain}`;
+		this._watchedAddresses = new Set<string>();
+	}
+
+	async init(): Promise<void> {
+		const saved = await this.cursorStore.get(this.watcherId);
+		if (saved !== null) this._cursor = saved;
+	}
+
+	setWatchedAddresses(addresses: string[]): void {
+		this._watchedAddresses = new Set(addresses.map((a) => a.toLowerCase()));
+	}
+
+	getCursor(): number {
+		return this._cursor;
+	}
+
+	stop(): void {
+		this._stopped = true;
+	}
+
+	/**
+	 * Poll for native ETH transfers to watched addresses, including unconfirmed blocks.
+	 *
+	 * Scans from cursor to latest block in batches of 5. Emits events with current
+	 * confirmation count. Re-emits on each confirmation increment. Only advances
+	 * cursor past fully-confirmed blocks.
+	 */
+	async poll(): Promise<PaymentEvent[]> {
+		if (this._stopped || this._watchedAddresses.size === 0) return [];
+
+		const latestHex = (await this.rpc("eth_blockNumber", [])) as string;
+		const latest = Number.parseInt(latestHex, 16);
+		const confirmed = latest - this.confirmations;
+
+		if (latest < this._cursor) return [];
+
+		const { priceMicros } = await this.oracle.getPrice("ETH");
+
+		const events: PaymentEvent[] = [];
+
+		// Fetch blocks in batches to avoid bursting RPC rate limits on fast chains.
+		const BATCH_SIZE = 5;
+		for (let batchStart = this._cursor; batchStart <= latest; batchStart += BATCH_SIZE) {
+			if (this._stopped) break;
+
+			const batchEnd = Math.min(batchStart + BATCH_SIZE - 1, latest);
+			const blockNums = Array.from({ length: batchEnd - batchStart + 1 }, (_, i) => batchStart + i);
+
+			const blocks = await Promise.all(
+				blockNums.map((bn) =>
+					this.rpc("eth_getBlockByNumber", [`0x${bn.toString(16)}`, true]).then(
+						(b) => ({ blockNum: bn, block: b as { transactions: RpcTransaction[] } | null, error: null }),
+						(err: unknown) => ({ blockNum: bn, block: null, error: err }),
+					),
+				),
+			);
+
+			// Stop processing at the first failed block so the cursor doesn't advance past it.
+			const firstFailIdx = blocks.findIndex((b) => b.error !== null || !b.block);
+			const safeBlocks = firstFailIdx === -1 ? blocks : blocks.slice(0, firstFailIdx);
+			for (const { blockNum, block } of safeBlocks) {
+				if (!block) break;
+
+				const confs = latest - blockNum;
+
+				for (const tx of block.transactions) {
+					if (!tx.to) continue;
+					const to = tx.to.toLowerCase();
+					if (!this._watchedAddresses.has(to)) continue;
+
+					const valueWei = BigInt(tx.value);
+					if (valueWei === 0n) continue;
+
+					// Skip if we already emitted at this confirmation count
+					const lastConf = await this.cursorStore.getConfirmationCount(this.watcherId, tx.hash);
+					if (lastConf !== null && confs <= lastConf) continue;
+
+					const amountUsdCents = nativeToCents(valueWei, priceMicros, 18);
+
+					events.push({
+						chain: this.chain,
+						token: this.token,
+						from: tx.from.toLowerCase(),
+						to,
+						rawAmount: valueWei.toString(),
+						amountUsdCents,
+						txHash: tx.hash,
+						blockNumber: blockNum,
+						confirmations: confs,
+						confirmationsRequired: this.confirmations,
+					});
+
+					await this.cursorStore.saveConfirmationCount(this.watcherId, tx.hash, confs);
+				}
+
+				// Only advance cursor past fully-confirmed blocks
+				if (blockNum <= confirmed) {
+					this._cursor = blockNum + 1;
+					await this.cursorStore.save(this.watcherId, this._cursor);
+				}
+			}
+
+			if (firstFailIdx !== -1) break;
+		}
+
+		return events;
+	}
+}

package/src/evm/index.ts

@@ -0,0 +1,46 @@
+import type { IChainPlugin, SweeperOpts, WatcherOpts } from "@wopr-network/platform-core/crypto-plugin";
+import { EvmAddressEncoder } from "./encoder.js";
+import { EthWatcher } from "./eth-watcher.js";
+import { EvmWatcher } from "./watcher.js";
+
+export { EvmAddressEncoder } from "./encoder.js";
+export { EthWatcher } from "./eth-watcher.js";
+export type {
+	ChainConfig,
+	EvmChain,
+	RpcCall,
+	RpcLog,
+	RpcTransaction,
+	StablecoinToken,
+	TokenConfig,
+} from "./types.js";
+export { DEFAULT_CHAINS, DEFAULT_TOKENS } from "./types.js";
+export { createRpcCaller, EvmWatcher } from "./watcher.js";
+
+const encoder = new EvmAddressEncoder();
+
+/**
+ * EVM chain plugin.
+ *
+ * Supports ERC-20 stablecoin watching (EvmWatcher) and native ETH watching (EthWatcher).
+ * The watcher created depends on whether a contractAddress is provided in opts:
+ *   - With contractAddress: EvmWatcher (ERC-20 Transfer log scanner)
+ *   - Without contractAddress: EthWatcher (native ETH block scanner)
+ */
+export const evmPlugin: IChainPlugin = {
+	pluginId: "evm",
+	supportedCurve: "secp256k1",
+	encoders: {
+		evm: encoder,
+	},
+	createWatcher(opts: WatcherOpts) {
+		if (opts.contractAddress) {
+			return new EvmWatcher(opts);
+		}
+		return new EthWatcher(opts);
+	},
+	createSweeper(_opts: SweeperOpts) {
+		throw new Error("Not implemented — EVM sweeper is planned for Phase 3");
+	},
+	version: 1,
+};

package/src/evm/types.ts

@@ -0,0 +1,146 @@
+/** Supported EVM chains. */
+export type EvmChain = "base" | "ethereum" | "arbitrum" | "polygon" | (string & {});
+
+/** Supported stablecoin tokens. */
+export type StablecoinToken = "USDC" | "USDT" | "DAI";
+
+/** Chain configuration. */
+export interface ChainConfig {
+	readonly chain: EvmChain;
+	readonly rpcUrl: string;
+	readonly confirmations: number;
+	readonly blockTimeMs: number;
+	readonly chainId: number;
+}
+
+/** Token configuration on a specific chain. */
+export interface TokenConfig {
+	readonly token: StablecoinToken;
+	readonly chain: EvmChain;
+	readonly contractAddress: `0x${string}`;
+	readonly decimals: number;
+}
+
+/** JSON-RPC call function signature. */
+export type RpcCall = (method: string, params: unknown[]) => Promise<unknown>;
+
+/** Raw JSON-RPC log entry. */
+export interface RpcLog {
+	address: string;
+	topics: string[];
+	data: string;
+	blockNumber: string;
+	transactionHash: string;
+	logIndex: string;
+}
+
+/** Raw JSON-RPC transaction entry. */
+export interface RpcTransaction {
+	hash: string;
+	from: string;
+	to: string | null;
+	value: string;
+	blockNumber: string;
+}
+
+/** Default chain configurations. */
+export const DEFAULT_CHAINS: Record<string, ChainConfig> = {
+	base: {
+		chain: "base",
+		rpcUrl: "http://op-geth:8545",
+		confirmations: 1,
+		blockTimeMs: 2000,
+		chainId: 8453,
+	},
+	ethereum: {
+		chain: "ethereum",
+		rpcUrl: "http://geth:8545",
+		confirmations: 12,
+		blockTimeMs: 12000,
+		chainId: 1,
+	},
+	arbitrum: {
+		chain: "arbitrum",
+		rpcUrl: "http://nitro:8547",
+		confirmations: 1,
+		blockTimeMs: 250,
+		chainId: 42161,
+	},
+	polygon: {
+		chain: "polygon",
+		rpcUrl: "http://bor:8545",
+		confirmations: 32,
+		blockTimeMs: 2000,
+		chainId: 137,
+	},
+};
+
+/** Default stablecoin token configs. */
+export const DEFAULT_TOKENS: Record<string, TokenConfig> = {
+	"USDC:base": {
+		token: "USDC",
+		chain: "base",
+		contractAddress: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+		decimals: 6,
+	},
+	"USDT:base": {
+		token: "USDT",
+		chain: "base",
+		contractAddress: "0xfde4C96c8593536E31F229EA8f37b2ADa2699bb2",
+		decimals: 6,
+	},
+	"DAI:base": {
+		token: "DAI",
+		chain: "base",
+		contractAddress: "0x50c5725949A6F0c72E6C4a641F24049A917DB0Cb",
+		decimals: 18,
+	},
+	"USDC:ethereum": {
+		token: "USDC",
+		chain: "ethereum",
+		contractAddress: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+		decimals: 6,
+	},
+	"USDT:ethereum": {
+		token: "USDT",
+		chain: "ethereum",
+		contractAddress: "0xdAC17F958D2ee523a2206206994597C13D831ec7",
+		decimals: 6,
+	},
+	"DAI:ethereum": {
+		token: "DAI",
+		chain: "ethereum",
+		contractAddress: "0x6B175474E89094C44Da98b954EedeAC495271d0F",
+		decimals: 18,
+	},
+	"USDC:arbitrum": {
+		token: "USDC",
+		chain: "arbitrum",
+		contractAddress: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
+		decimals: 6,
+	},
+	"USDT:arbitrum": {
+		token: "USDT",
+		chain: "arbitrum",
+		contractAddress: "0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9",
+		decimals: 6,
+	},
+	"DAI:arbitrum": {
+		token: "DAI",
+		chain: "arbitrum",
+		contractAddress: "0xDA10009cBd5D07dd0CeCc66161FC93D7c9000da1",
+		decimals: 18,
+	},
+	"USDC:polygon": {
+		token: "USDC",
+		chain: "polygon",
+		contractAddress: "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359",
+		decimals: 6,
+	},
+	"USDT:polygon": {
+		token: "USDT",
+		chain: "polygon",
+		contractAddress: "0xc2132D05D31c914a87C6611C10748AEb04B58e8F",
+		decimals: 6,
+	},
+};

package/src/evm/watcher.ts

@@ -0,0 +1,189 @@
+import type {
+	IChainWatcher,
+	IWatcherCursorStore,
+	PaymentEvent,
+	WatcherOpts,
+} from "@wopr-network/platform-core/crypto-plugin";
+import type { RpcCall, RpcLog } from "./types.js";
+
+const TRANSFER_TOPIC = "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef";
+
+/** Create an RPC caller for a given URL (plain JSON-RPC over fetch). */
+export function createRpcCaller(rpcUrl: string, extraHeaders?: Record<string, string>): RpcCall {
+	let id = 0;
+	const headers: Record<string, string> = { "Content-Type": "application/json", ...extraHeaders };
+	return async (method: string, params: unknown[]): Promise<unknown> => {
+		const res = await fetch(rpcUrl, {
+			method: "POST",
+			headers,
+			body: JSON.stringify({ jsonrpc: "2.0", id: ++id, method, params }),
+		});
+		if (!res.ok) {
+			const body = await res.text().catch(() => "");
+			const hasApiKey = "TRON-PRO-API-KEY" in headers;
+			console.error(
+				`[rpc] ${method} ${res.status} auth=${hasApiKey} url=${rpcUrl.replace(/apikey=[^&]+/, "apikey=***")} body=${body.slice(0, 200)}`,
+			);
+			throw new Error(`RPC ${method} failed: ${res.status}`);
+		}
+		const data = (await res.json()) as { result?: unknown; error?: { message: string } };
+		if (data.error) throw new Error(`RPC ${method} error: ${data.error.message}`);
+		return data.result;
+	};
+}
+
+/**
+ * Convert token raw amount (BigInt) to USD cents (integer).
+ * Stablecoins are 1:1 USD. Truncates fractional cents.
+ */
+function centsFromTokenAmount(rawAmount: bigint, decimals: number): number {
+	return Number((rawAmount * 100n) / 10n ** BigInt(decimals));
+}
+
+/**
+ * ERC-20 Transfer log scanner.
+ *
+ * Scans from cursor to latest block for Transfer events matching watched
+ * deposit addresses. Emits events with current confirmation count. Re-emits
+ * on each confirmation increment. Only advances cursor past fully-confirmed blocks.
+ */
+export class EvmWatcher implements IChainWatcher {
+	private _cursor = 0;
+	private _stopped = false;
+	private readonly chain: string;
+	private readonly token: string;
+	private readonly rpc: RpcCall;
+	private readonly confirmations: number;
+	private readonly contractAddress: string;
+	private readonly decimals: number;
+	private readonly cursorStore: IWatcherCursorStore;
+	private readonly watcherId: string;
+	private _watchedAddresses: string[];
+
+	constructor(opts: WatcherOpts) {
+		this.chain = opts.chain;
+		this.token = opts.token;
+		this.rpc = createRpcCaller(opts.rpcUrl, opts.rpcHeaders);
+		this._cursor = 0;
+		this.confirmations = opts.confirmations;
+		this.contractAddress = (opts.contractAddress ?? "").toLowerCase();
+		this.decimals = opts.decimals;
+		this.cursorStore = opts.cursorStore;
+		this.watcherId = `evm:${opts.chain}:${opts.token}`;
+		this._watchedAddresses = [];
+	}
+
+	async init(): Promise<void> {
+		const saved = await this.cursorStore.get(this.watcherId);
+		if (saved !== null) this._cursor = saved;
+	}
+
+	setWatchedAddresses(addresses: string[]): void {
+		this._watchedAddresses = addresses.map((a) => a.toLowerCase());
+	}
+
+	getCursor(): number {
+		return this._cursor;
+	}
+
+	stop(): void {
+		this._stopped = true;
+	}
+
+	/**
+	 * Poll for ERC-20 Transfer events, including pending (unconfirmed) blocks.
+	 *
+	 * Two-phase scan:
+	 *   1. Scan cursor..latest for new/updated txs, emit with current confirmation count
+	 *   2. Re-check pending txs automatically since cursor doesn't advance past unconfirmed blocks
+	 *
+	 * Cursor only advances past fully-confirmed blocks.
+	 *
+	 * Returns PaymentEvent[] instead of using callbacks.
+	 */
+	async poll(): Promise<PaymentEvent[]> {
+		if (this._stopped || this._watchedAddresses.length === 0) return [];
+
+		const latestHex = (await this.rpc("eth_blockNumber", [])) as string;
+		const latest = Number.parseInt(latestHex, 16);
+		const confirmed = latest - this.confirmations;
+
+		if (latest < this._cursor) return [];
+
+		// Filter by topic[2] (to address) when watched addresses are set.
+		const toFilter =
+			this._watchedAddresses.length > 0
+				? this._watchedAddresses.map((a) => `0x000000000000000000000000${a.slice(2)}`)
+				: null;
+
+		// Scan from cursor to latest (not just confirmed) to detect pending txs
+		const logs = (await this.rpc("eth_getLogs", [
+			{
+				address: this.contractAddress,
+				topics: [TRANSFER_TOPIC, null, toFilter],
+				fromBlock: `0x${this._cursor.toString(16)}`,
+				toBlock: `0x${latest.toString(16)}`,
+			},
+		])) as RpcLog[];
+
+		// Group logs by block
+		const logsByBlock = new Map<number, RpcLog[]>();
+		for (const log of logs) {
+			const bn = Number.parseInt(log.blockNumber, 16);
+			const arr = logsByBlock.get(bn);
+			if (arr) arr.push(log);
+			else logsByBlock.set(bn, [log]);
+		}
+
+		const events: PaymentEvent[] = [];
+
+		// Process all blocks (including unconfirmed), emit with confirmation count
+		const blockNums = [...logsByBlock.keys()].sort((a, b) => a - b);
+		for (const blockNum of blockNums) {
+			const confs = latest - blockNum;
+
+			for (const log of logsByBlock.get(blockNum) ?? []) {
+				const txKey = `${log.transactionHash}:${log.logIndex}`;
+
+				// Skip if we already emitted at this confirmation count
+				const lastConf = await this.cursorStore.getConfirmationCount(this.watcherId, txKey);
+				if (lastConf !== null && confs <= lastConf) continue;
+
+				const to = `0x${log.topics[2].slice(26)}`.toLowerCase();
+				const from = `0x${log.topics[1].slice(26)}`.toLowerCase();
+				const rawAmount = BigInt(log.data);
+				const amountUsdCents = centsFromTokenAmount(rawAmount, this.decimals);
+
+				events.push({
+					chain: this.chain,
+					token: this.token,
+					from,
+					to,
+					rawAmount: rawAmount.toString(),
+					amountUsdCents,
+					txHash: log.transactionHash,
+					blockNumber: blockNum,
+					confirmations: confs,
+					confirmationsRequired: this.confirmations,
+				});
+
+				// Track confirmation count
+				await this.cursorStore.saveConfirmationCount(this.watcherId, txKey, confs);
+			}
+
+			// Only advance cursor past fully-confirmed blocks
+			if (blockNum <= confirmed) {
+				this._cursor = blockNum + 1;
+				await this.cursorStore.save(this.watcherId, this._cursor);
+			}
+		}
+
+		// Advance cursor if no logs found but confirmed blocks exist
+		if (blockNums.length === 0 && confirmed >= this._cursor) {
+			this._cursor = confirmed + 1;
+			await this.cursorStore.save(this.watcherId, this._cursor);
+		}
+
+		return events;
+	}
+}

package/src/index.ts

@@ -0,0 +1,21 @@
+export { bitcoinPlugin } from "./bitcoin/index.js";
+export { dogecoinPlugin, encodeP2pkhAddress, p2pkhEncoder } from "./dogecoin/index.js";
+export { evmPlugin } from "./evm/index.js";
+export { bech32Encoder as ltcBech32Encoder, litecoinPlugin } from "./litecoin/index.js";
+export {
+	base58Encode,
+	createSolanaRpcCaller,
+	SolanaAddressEncoder,
+	SolanaSweeper,
+	SolanaWatcher,
+	solanaPlugin,
+} from "./solana/index.js";
+export {
+	encodeKeccakB58Address,
+	hexToTron,
+	isTronAddress,
+	keccakB58Encoder,
+	TronEvmWatcher,
+	tronPlugin,
+	tronToHex,
+} from "./tron/index.js";

package/src/litecoin/encoder.ts

@@ -0,0 +1,18 @@
+import type { EncodingParams, IAddressEncoder } from "@wopr-network/platform-core/crypto-plugin";
+
+import { encodeBech32Address } from "../bitcoin/encoder.js";
+
+/**
+ * Litecoin bech32 address encoder.
+ * Implements IAddressEncoder for the litecoin plugin.
+ * Default HRP is "ltc" (mainnet). Override with params.hrp for testnet ("tltc").
+ */
+export const bech32Encoder: IAddressEncoder = {
+	encode(publicKey: Uint8Array, params: EncodingParams): string {
+		const hrp = params.hrp ?? "ltc";
+		return encodeBech32Address(publicKey, hrp);
+	},
+	encodingType(): string {
+		return "bech32";
+	},
+};

package/src/litecoin/index.ts

@@ -0,0 +1,23 @@
+import type { IChainPlugin, WatcherOpts } from "@wopr-network/platform-core/crypto-plugin";
+
+import { createRpcFromOpts } from "../shared/utxo/index.js";
+import { createUtxoWatcher } from "../shared/utxo/watcher.js";
+import { bech32Encoder } from "./encoder.js";
+
+export { bech32Encoder } from "./encoder.js";
+
+export const litecoinPlugin: IChainPlugin = {
+	pluginId: "litecoin",
+	supportedCurve: "secp256k1",
+	encoders: {
+		bech32: bech32Encoder,
+	},
+	createWatcher(opts: WatcherOpts) {
+		const rpc = createRpcFromOpts(opts.rpcUrl, opts.rpcHeaders);
+		return createUtxoWatcher(opts, rpc);
+	},
+	createSweeper() {
+		throw new Error("Not implemented");
+	},
+	version: 1,
+};

package/src/shared/test-helpers/index.ts

@@ -0,0 +1,36 @@
+import type { IPriceOracle, IWatcherCursorStore } from "@wopr-network/platform-core/crypto-plugin";
+
+/** In-memory mock cursor store for testing UTXO watchers. */
+export function createMockCursorStore(): IWatcherCursorStore & {
+	_cursors: Map<string, number>;
+	_confirmations: Map<string, number>;
+} {
+	const cursors = new Map<string, number>();
+	const confirmations = new Map<string, number>();
+
+	return {
+		_cursors: cursors,
+		_confirmations: confirmations,
+		async get(watcherId: string): Promise<number | null> {
+			return cursors.get(watcherId) ?? null;
+		},
+		async save(watcherId: string, cursor: number): Promise<void> {
+			cursors.set(watcherId, cursor);
+		},
+		async getConfirmationCount(watcherId: string, txKey: string): Promise<number | null> {
+			return confirmations.get(`${watcherId}:${txKey}`) ?? null;
+		},
+		async saveConfirmationCount(watcherId: string, txKey: string, count: number): Promise<void> {
+			confirmations.set(`${watcherId}:${txKey}`, count);
+		},
+	};
+}
+
+/** Mock price oracle that returns a fixed price. */
+export function createMockOracle(priceMicros = 100_000_000_000): IPriceOracle {
+	return {
+		async getPrice(_token: string) {
+			return { priceMicros };
+		},
+	};
+}

package/src/shared/utxo/index.ts

@@ -0,0 +1,12 @@
+export { createBitcoindRpc, createRpcFromOpts, parseRpcUrl } from "./rpc.js";
+export type {
+	DescriptorInfo,
+	GetTransactionResponse,
+	ImportDescriptorResult,
+	ReceivedByAddress,
+	RpcCall,
+	TxDetail,
+	UtxoNodeConfig,
+} from "./types.js";
+export type { UtxoWatcherConfig } from "./watcher.js";
+export { createUtxoWatcher, UtxoWatcher } from "./watcher.js";