@wopr-network/crypto-plugins 1.0.1

package/src/__tests__/sweep-key-parity.test.ts

@@ -0,0 +1,302 @@
+import { ed25519 } from "@noble/curves/ed25519.js";
+import { hmac } from "@noble/hashes/hmac.js";
+import { sha512 } from "@noble/hashes/sha2.js";
+import { HDKey } from "@scure/bip32";
+import * as bip39 from "@scure/bip39";
+import { privateKeyToAccount } from "viem/accounts";
+import { describe, expect, it } from "vitest";
+
+import { bech32Encoder } from "../bitcoin/encoder.js";
+import { p2pkhEncoder } from "../dogecoin/encoder.js";
+import { EvmAddressEncoder } from "../evm/encoder.js";
+import { bech32Encoder as ltcBech32Encoder } from "../litecoin/encoder.js";
+import { SolanaAddressEncoder } from "../solana/encoder.js";
+import { keccakB58Encoder } from "../tron/encoder.js";
+
+// ---------------------------------------------------------------------------
+// Well-known BIP-39 test mnemonic (public, never use in production)
+// ---------------------------------------------------------------------------
+
+const TEST_MNEMONIC = "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about";
+const TEST_SEED = bip39.mnemonicToSeedSync(TEST_MNEMONIC);
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function toHex(bytes: Uint8Array): string {
+	return Array.from(bytes as unknown as number[], (b: number) => b.toString(16).padStart(2, "0")).join("");
+}
+
+function privKeyHex(key: Uint8Array): `0x${string}` {
+	return `0x${toHex(key)}` as `0x${string}`;
+}
+
+// ---------------------------------------------------------------------------
+// secp256k1 chain configs
+// ---------------------------------------------------------------------------
+
+interface Secp256k1ChainConfig {
+	name: string;
+	coinType: number;
+	encoder: { encode(pk: Uint8Array, params: Record<string, unknown>): string };
+	params: Record<string, unknown>;
+	addrRegex: RegExp;
+}
+
+const SECP256K1_CHAINS: Secp256k1ChainConfig[] = [
+	{
+		name: "Bitcoin",
+		coinType: 0,
+		encoder: bech32Encoder,
+		params: { hrp: "bc" },
+		addrRegex: /^bc1q/,
+	},
+	{
+		name: "Litecoin",
+		coinType: 2,
+		encoder: ltcBech32Encoder,
+		params: { hrp: "ltc" },
+		addrRegex: /^ltc1q/,
+	},
+	{
+		name: "Dogecoin",
+		coinType: 3,
+		encoder: p2pkhEncoder,
+		params: { version: "0x1e" },
+		addrRegex: /^D/,
+	},
+	{
+		name: "EVM",
+		coinType: 60,
+		encoder: new EvmAddressEncoder(),
+		params: {},
+		addrRegex: /^0x[0-9a-fA-F]{40}$/,
+	},
+	{
+		name: "Tron",
+		coinType: 195,
+		encoder: keccakB58Encoder,
+		params: { version: "0x41" },
+		addrRegex: /^T/,
+	},
+];
+
+// ---------------------------------------------------------------------------
+// SLIP-0010 Ed25519 derivation (manual, since @scure/bip32 is secp256k1 only)
+// ---------------------------------------------------------------------------
+
+interface Slip0010Key {
+	privateKey: Uint8Array;
+	chainCode: Uint8Array;
+}
+
+function slip0010MasterKey(seed: Uint8Array): Slip0010Key {
+	const I = hmac(sha512, new TextEncoder().encode("ed25519 seed"), seed);
+	return {
+		privateKey: I.slice(0, 32),
+		chainCode: I.slice(32),
+	};
+}
+
+function slip0010DeriveChild(parent: Slip0010Key, index: number): Slip0010Key {
+	// SLIP-0010 Ed25519: only hardened derivation (index >= 0x80000000)
+	const hardenedIndex = (index | 0x80000000) >>> 0;
+	const data = new Uint8Array(1 + 32 + 4);
+	data[0] = 0x00;
+	data.set(parent.privateKey, 1);
+	const view = new DataView(data.buffer);
+	view.setUint32(33, hardenedIndex, false); // big-endian
+	const I = hmac(sha512, parent.chainCode, data);
+	return {
+		privateKey: I.slice(0, 32),
+		chainCode: I.slice(32),
+	};
+}
+
+function slip0010DerivePath(seed: Uint8Array, path: number[]): Slip0010Key {
+	let key = slip0010MasterKey(seed);
+	for (const index of path) {
+		key = slip0010DeriveChild(key, index);
+	}
+	return key;
+}
+
+// ===========================================================================
+// Tests
+// ===========================================================================
+
+describe("sweep key parity -- mnemonic private key controls derived address", () => {
+	// -----------------------------------------------------------------------
+	// secp256k1 chains: pubkey from xpub must equal pubkey from privkey
+	// -----------------------------------------------------------------------
+
+	describe("secp256k1 chains", () => {
+		for (const chain of SECP256K1_CHAINS) {
+			const path = `m/44'/${chain.coinType}'/0'`;
+
+			it(`${chain.name}: privkey pubkey matches xpub pubkey at indices 0-4`, () => {
+				const masterHD = HDKey.fromMasterSeed(TEST_SEED);
+				const accountKey = masterHD.derive(path);
+				const xpub = accountKey.publicExtendedKey;
+
+				for (let i = 0; i < 5; i++) {
+					// From full key (has private key): derive external chain (0), index i
+					const fullChild = accountKey.deriveChild(0).deriveChild(i);
+					// From xpub only: derive external chain (0), index i
+					const xpubChild = HDKey.fromExtendedKey(xpub).deriveChild(0).deriveChild(i);
+
+					const fullPk = fullChild.publicKey as Uint8Array;
+					const xpubPk = xpubChild.publicKey as Uint8Array;
+
+					expect(fullPk).toBeDefined();
+					expect(xpubPk).toBeDefined();
+					expect(toHex(fullPk)).toBe(toHex(xpubPk));
+				}
+			});
+
+			it(`${chain.name}: encoder produces valid address from derived pubkey`, () => {
+				const masterHD = HDKey.fromMasterSeed(TEST_SEED);
+				const accountKey = masterHD.derive(path);
+				const xpub = accountKey.publicExtendedKey;
+
+				for (let i = 0; i < 5; i++) {
+					const xpubChild = HDKey.fromExtendedKey(xpub).deriveChild(0).deriveChild(i);
+					const pubkey = xpubChild.publicKey as Uint8Array;
+					const address = chain.encoder.encode(pubkey, chain.params);
+
+					expect(address).toMatch(chain.addrRegex);
+				}
+			});
+
+			it(`${chain.name}: different indices produce different addresses`, () => {
+				const masterHD = HDKey.fromMasterSeed(TEST_SEED);
+				const accountKey = masterHD.derive(path);
+				const xpub = accountKey.publicExtendedKey;
+
+				const addresses = new Set<string>();
+				for (let i = 0; i < 5; i++) {
+					const xpubChild = HDKey.fromExtendedKey(xpub).deriveChild(0).deriveChild(i);
+					const pubkey = xpubChild.publicKey as Uint8Array;
+					const address = chain.encoder.encode(pubkey, chain.params);
+					addresses.add(address);
+				}
+				expect(addresses.size).toBe(5);
+			});
+
+			it(`${chain.name}: derivation is deterministic`, () => {
+				const masterHD = HDKey.fromMasterSeed(TEST_SEED);
+				const accountKey = masterHD.derive(path);
+				const xpub = accountKey.publicExtendedKey;
+
+				const xpubChild = HDKey.fromExtendedKey(xpub).deriveChild(0).deriveChild(3);
+				const pubkey = xpubChild.publicKey as Uint8Array;
+				const addr1 = chain.encoder.encode(pubkey, chain.params);
+				const addr2 = chain.encoder.encode(pubkey, chain.params);
+				expect(addr1).toBe(addr2);
+			});
+		}
+	});
+
+	// -----------------------------------------------------------------------
+	// EVM signing proof: viem privateKeyToAccount matches encoder output
+	// -----------------------------------------------------------------------
+
+	describe("EVM signing proof", () => {
+		it("viem privateKeyToAccount matches encoder output at indices 0-9", () => {
+			const evmPath = "m/44'/60'/0'";
+			const masterHD = HDKey.fromMasterSeed(TEST_SEED);
+			const accountKey = masterHD.derive(evmPath);
+			const encoder = new EvmAddressEncoder();
+
+			for (let i = 0; i < 10; i++) {
+				const child = accountKey.deriveChild(0).deriveChild(i);
+				const privKey = child.privateKey as Uint8Array;
+				const pubKey = child.publicKey as Uint8Array;
+
+				// Address from encoder (pubkey -> keccak -> EIP-55)
+				const encoderAddr = encoder.encode(pubKey, {});
+
+				// Address from viem (privkey -> account -> address)
+				const viemAccount = privateKeyToAccount(privKeyHex(privKey));
+
+				expect(viemAccount.address.toLowerCase()).toBe(encoderAddr.toLowerCase());
+			}
+		});
+
+		it("viem treasury key matches encoder output", () => {
+			const evmPath = "m/44'/60'/0'";
+			const masterHD = HDKey.fromMasterSeed(TEST_SEED);
+			const accountKey = masterHD.derive(evmPath);
+			const encoder = new EvmAddressEncoder();
+
+			// Treasury: chain index 1, address index 0
+			const child = accountKey.deriveChild(1).deriveChild(0);
+			const privKey = child.privateKey as Uint8Array;
+			const pubKey = child.publicKey as Uint8Array;
+
+			const encoderAddr = encoder.encode(pubKey, {});
+			const viemAccount = privateKeyToAccount(privKeyHex(privKey));
+
+			expect(viemAccount.address.toLowerCase()).toBe(encoderAddr.toLowerCase());
+		});
+	});
+
+	// -----------------------------------------------------------------------
+	// Solana Ed25519 (SLIP-0010 derivation)
+	// -----------------------------------------------------------------------
+
+	describe("Solana Ed25519", () => {
+		const solanaEncoder = new SolanaAddressEncoder();
+
+		it("SLIP-0010 derivation produces valid Solana address", () => {
+			// m/44'/501'/0'/0' -- all hardened for SLIP-0010 Ed25519
+			const derived = slip0010DerivePath(TEST_SEED, [44, 501, 0, 0]);
+			const publicKey = ed25519.getPublicKey(derived.privateKey);
+
+			expect(publicKey.length).toBe(32);
+
+			const address = solanaEncoder.encode(publicKey, {});
+
+			// Valid Base58 string, typical Solana address length 32-44 chars
+			expect(address).toMatch(/^[1-9A-HJ-NP-Za-km-z]+$/);
+			expect(address.length).toBeGreaterThanOrEqual(32);
+			expect(address.length).toBeLessThanOrEqual(44);
+		});
+
+		it("same seed always produces same address", () => {
+			const derived1 = slip0010DerivePath(TEST_SEED, [44, 501, 0, 0]);
+			const pub1 = ed25519.getPublicKey(derived1.privateKey);
+			const addr1 = solanaEncoder.encode(pub1, {});
+
+			const derived2 = slip0010DerivePath(TEST_SEED, [44, 501, 0, 0]);
+			const pub2 = ed25519.getPublicKey(derived2.privateKey);
+			const addr2 = solanaEncoder.encode(pub2, {});
+
+			expect(addr1).toBe(addr2);
+		});
+
+		it("different account indices produce different addresses", () => {
+			const addresses = new Set<string>();
+			for (let i = 0; i < 5; i++) {
+				// m/44'/501'/i'/0'
+				const derived = slip0010DerivePath(TEST_SEED, [44, 501, i, 0]);
+				const publicKey = ed25519.getPublicKey(derived.privateKey);
+				const address = solanaEncoder.encode(publicKey, {});
+				addresses.add(address);
+			}
+			expect(addresses.size).toBe(5);
+		});
+
+		it("privkey and pubkey are consistent via Ed25519", () => {
+			const derived = slip0010DerivePath(TEST_SEED, [44, 501, 0, 0]);
+			const publicKey = ed25519.getPublicKey(derived.privateKey);
+
+			// Sign something and verify to prove the key pair is valid
+			const message = new TextEncoder().encode("test message");
+			const signature = ed25519.sign(message, derived.privateKey);
+			const valid = ed25519.verify(signature, message, publicKey);
+			expect(valid).toBe(true);
+		});
+	});
+});

package/src/__tests__/tron-encoder.test.ts

@@ -0,0 +1,108 @@
+import { HDKey } from "@scure/bip32";
+import { describe, expect, it } from "vitest";
+import { hexToTron, isTronAddress, tronToHex } from "../tron/address-convert.js";
+import { encodeKeccakB58Address, keccakB58Encoder } from "../tron/encoder.js";
+
+const TEST_XPUB =
+	"xpub6BnqJwdqnXEZdkynN5CsrYZr3MULY933SdLrswFfKPDFandTXPQDWY225FveTPUJXS8D91Ddp7FEfaGrvVxuMBGQsyoBYRLu6VMB3Ni2H2Z";
+
+function derivePublicKey(xpub: string, index: number): Uint8Array {
+	const master = HDKey.fromExtendedKey(xpub);
+	const child = master.deriveChild(0).deriveChild(index);
+	if (!child.publicKey) throw new Error("Failed to derive public key");
+	return child.publicKey;
+}
+
+describe("Tron keccak-b58check encoder", () => {
+	it("produces T... addresses with default version byte 0x41", () => {
+		const pubkey = derivePublicKey(TEST_XPUB, 0);
+		const address = keccakB58Encoder.encode(pubkey, {});
+		expect(address).toMatch(/^T[1-9A-HJ-NP-Za-km-z]+$/);
+	});
+
+	it("index 0 produces TDTkBJWfXqfCPhNAgHxmgPNHigJEg4ghww", () => {
+		const pubkey = derivePublicKey(TEST_XPUB, 0);
+		const address = keccakB58Encoder.encode(pubkey, {});
+		expect(address).toBe("TDTkBJWfXqfCPhNAgHxmgPNHigJEg4ghww");
+	});
+
+	it("produces different addresses for different indices", () => {
+		const addr0 = keccakB58Encoder.encode(derivePublicKey(TEST_XPUB, 0), {});
+		const addr1 = keccakB58Encoder.encode(derivePublicKey(TEST_XPUB, 1), {});
+		expect(addr0).not.toBe(addr1);
+	});
+
+	it("produces consistent results for the same key", () => {
+		const pubkey = derivePublicKey(TEST_XPUB, 0);
+		const addr1 = keccakB58Encoder.encode(pubkey, {});
+		const addr2 = keccakB58Encoder.encode(pubkey, {});
+		expect(addr1).toBe(addr2);
+	});
+
+	it("respects custom version param", () => {
+		const pubkey = derivePublicKey(TEST_XPUB, 0);
+		// Different version byte produces different address
+		const addr41 = keccakB58Encoder.encode(pubkey, {});
+		const addr00 = keccakB58Encoder.encode(pubkey, { version: "0" });
+		expect(addr41).not.toBe(addr00);
+	});
+
+	it("encodeKeccakB58Address function works directly", () => {
+		const pubkey = derivePublicKey(TEST_XPUB, 0);
+		const address = encodeKeccakB58Address(pubkey, 0x41);
+		expect(address).toMatch(/^T/);
+	});
+
+	it("reports encoding type as keccak-b58check", () => {
+		expect(keccakB58Encoder.encodingType()).toBe("keccak-b58check");
+	});
+
+	it("addresses only contain valid Base58 characters", () => {
+		const pubkey = derivePublicKey(TEST_XPUB, 0);
+		const address = keccakB58Encoder.encode(pubkey, {});
+		expect(address).not.toMatch(/[0OIl]/);
+	});
+});
+
+describe("Tron address conversion", () => {
+	it("tronToHex converts T... to 0x hex", () => {
+		const pubkey = derivePublicKey(TEST_XPUB, 0);
+		const tronAddr = keccakB58Encoder.encode(pubkey, {});
+		const hex = tronToHex(tronAddr);
+		expect(hex).toMatch(/^0x[0-9a-f]{40}$/);
+	});
+
+	it("hexToTron converts 0x hex back to T...", () => {
+		const pubkey = derivePublicKey(TEST_XPUB, 0);
+		const tronAddr = keccakB58Encoder.encode(pubkey, {});
+		const hex = tronToHex(tronAddr);
+		const roundTrip = hexToTron(hex);
+		expect(roundTrip).toBe(tronAddr);
+	});
+
+	it("tronToHex throws on non-T address", () => {
+		expect(() => tronToHex("D7abc123")).toThrow("Not a Tron address");
+	});
+
+	it("hexToTron throws on wrong-length hex", () => {
+		expect(() => hexToTron("0x1234")).toThrow("Invalid hex address length");
+	});
+
+	it("isTronAddress detects T... addresses", () => {
+		const pubkey = derivePublicKey(TEST_XPUB, 0);
+		const tronAddr = keccakB58Encoder.encode(pubkey, {});
+		expect(isTronAddress(tronAddr)).toBe(true);
+		expect(isTronAddress("0x1234567890abcdef1234567890abcdef12345678")).toBe(false);
+		expect(isTronAddress("D7abcdef")).toBe(false);
+	});
+
+	it("round-trip through multiple addresses", () => {
+		for (let i = 0; i < 5; i++) {
+			const pubkey = derivePublicKey(TEST_XPUB, i);
+			const tronAddr = keccakB58Encoder.encode(pubkey, {});
+			const hex = tronToHex(tronAddr);
+			const back = hexToTron(hex);
+			expect(back).toBe(tronAddr);
+		}
+	});
+});

package/src/__tests__/utxo-watcher.test.ts

@@ -0,0 +1,252 @@
+import { describe, expect, it, vi } from "vitest";
+import { createMockCursorStore, createMockOracle } from "../shared/test-helpers/index.js";
+import type { RpcCall } from "../shared/utxo/types.js";
+import { UtxoWatcher } from "../shared/utxo/watcher.js";
+
+function createTestWatcher(rpc: RpcCall, opts?: { confirmations?: number; token?: string; chain?: string }) {
+	const cursorStore = createMockCursorStore();
+	const oracle = createMockOracle();
+	const watcher = new UtxoWatcher({
+		rpc,
+		token: opts?.token ?? "BTC",
+		chain: opts?.chain ?? "bitcoin",
+		decimals: 8,
+		confirmations: opts?.confirmations ?? 3,
+		oracle,
+		cursorStore,
+	});
+	return { watcher, cursorStore, oracle };
+}
+
+describe("UtxoWatcher", () => {
+	it("returns empty array when no addresses are watched", async () => {
+		const rpc = vi.fn();
+		const { watcher } = createTestWatcher(rpc);
+		const events = await watcher.poll();
+		expect(events).toEqual([]);
+		expect(rpc).not.toHaveBeenCalled();
+	});
+
+	it("detects a payment with confirmations", async () => {
+		const rpc = vi.fn<RpcCall>().mockImplementation(async (method, _params) => {
+			if (method === "listreceivedbyaddress") {
+				return [{ address: "bc1qtest", amount: 0.001, confirmations: 3, txids: ["tx1"] }];
+			}
+			if (method === "gettransaction") {
+				return {
+					details: [{ address: "bc1qtest", amount: 0.001, category: "receive" }],
+					confirmations: 3,
+				};
+			}
+			return null;
+		});
+
+		const { watcher } = createTestWatcher(rpc, { confirmations: 3 });
+		watcher.setWatchedAddresses(["bc1qtest"]);
+
+		const events = await watcher.poll();
+		expect(events).toHaveLength(1);
+		expect(events[0]!.chain).toBe("bitcoin");
+		expect(events[0]!.token).toBe("BTC");
+		expect(events[0]!.to).toBe("bc1qtest");
+		expect(events[0]!.txHash).toBe("tx1");
+		expect(events[0]!.confirmations).toBe(3);
+		expect(events[0]!.confirmationsRequired).toBe(3);
+		// 0.001 BTC = 100,000 sats. priceMicros=100_000_000_000 (=$100,000).
+		// nativeToCents(100000, 100000000000, 8) = (100000 * 100000000000) / (10000 * 10^8) = 10000000000000000 / 1000000000000 = 10000
+		expect(events[0]!.rawAmount).toBe("100000");
+		expect(events[0]!.amountUsdCents).toBe(10000); // $100.00
+	});
+
+	it("skips addresses not in the watch set", async () => {
+		const rpc = vi.fn<RpcCall>().mockImplementation(async (method) => {
+			if (method === "listreceivedbyaddress") {
+				return [{ address: "bc1qother", amount: 1.0, confirmations: 6, txids: ["tx2"] }];
+			}
+			return null;
+		});
+
+		const { watcher } = createTestWatcher(rpc);
+		watcher.setWatchedAddresses(["bc1qmine"]);
+
+		const events = await watcher.poll();
+		expect(events).toEqual([]);
+	});
+
+	it("skips txs that have not gained new confirmations", async () => {
+		const rpc = vi.fn<RpcCall>().mockImplementation(async (method) => {
+			if (method === "listreceivedbyaddress") {
+				return [{ address: "bc1qtest", amount: 0.5, confirmations: 2, txids: ["tx3"] }];
+			}
+			if (method === "gettransaction") {
+				return {
+					details: [{ address: "bc1qtest", amount: 0.5, category: "receive" }],
+					confirmations: 2,
+				};
+			}
+			return null;
+		});
+
+		const { watcher } = createTestWatcher(rpc, { confirmations: 6 });
+		watcher.setWatchedAddresses(["bc1qtest"]);
+
+		// First poll: should return event
+		const first = await watcher.poll();
+		expect(first).toHaveLength(1);
+
+		// Second poll with same confirmations: should skip
+		const second = await watcher.poll();
+		expect(second).toEqual([]);
+	});
+
+	it("emits new event when confirmations increase", async () => {
+		let confirmations = 1;
+		const rpc = vi.fn<RpcCall>().mockImplementation(async (method) => {
+			if (method === "listreceivedbyaddress") {
+				return [{ address: "bc1qtest", amount: 0.1, confirmations, txids: ["tx4"] }];
+			}
+			if (method === "gettransaction") {
+				return {
+					details: [{ address: "bc1qtest", amount: 0.1, category: "receive" }],
+					confirmations,
+				};
+			}
+			return null;
+		});
+
+		const { watcher } = createTestWatcher(rpc, { confirmations: 3 });
+		watcher.setWatchedAddresses(["bc1qtest"]);
+
+		const first = await watcher.poll();
+		expect(first).toHaveLength(1);
+		expect(first[0]!.confirmations).toBe(1);
+
+		confirmations = 2;
+		const second = await watcher.poll();
+		expect(second).toHaveLength(1);
+		expect(second[0]!.confirmations).toBe(2);
+
+		confirmations = 3;
+		const third = await watcher.poll();
+		expect(third).toHaveLength(1);
+		expect(third[0]!.confirmations).toBe(3);
+	});
+
+	it("does not emit events after stop()", async () => {
+		const rpc = vi.fn<RpcCall>().mockImplementation(async (method) => {
+			if (method === "listreceivedbyaddress") {
+				return [{ address: "bc1qtest", amount: 1.0, confirmations: 6, txids: ["tx5"] }];
+			}
+			return null;
+		});
+
+		const { watcher } = createTestWatcher(rpc);
+		watcher.setWatchedAddresses(["bc1qtest"]);
+		watcher.stop();
+
+		const events = await watcher.poll();
+		expect(events).toEqual([]);
+		expect(rpc).not.toHaveBeenCalled();
+	});
+
+	it("importAddress adds to watch set and calls RPC", async () => {
+		const rpc = vi.fn<RpcCall>().mockImplementation(async (method) => {
+			if (method === "getdescriptorinfo") {
+				return { descriptor: "addr(bc1qnew)#checksum" };
+			}
+			if (method === "importdescriptors") {
+				return [{ success: true }];
+			}
+			if (method === "listreceivedbyaddress") {
+				return [{ address: "bc1qnew", amount: 0.01, confirmations: 1, txids: ["tx6"] }];
+			}
+			if (method === "gettransaction") {
+				return {
+					details: [{ address: "bc1qnew", amount: 0.01, category: "receive" }],
+					confirmations: 1,
+				};
+			}
+			return null;
+		});
+
+		const { watcher } = createTestWatcher(rpc);
+		await watcher.importAddress("bc1qnew");
+
+		const events = await watcher.poll();
+		expect(events).toHaveLength(1);
+		expect(events[0]!.to).toBe("bc1qnew");
+	});
+
+	it("importAddress falls back to legacy importaddress on error", async () => {
+		const rpc = vi.fn<RpcCall>().mockImplementation(async (method) => {
+			if (method === "getdescriptorinfo") {
+				throw new Error("Method not found");
+			}
+			if (method === "importaddress") {
+				return null;
+			}
+			if (method === "listreceivedbyaddress") {
+				return [];
+			}
+			return null;
+		});
+
+		const { watcher } = createTestWatcher(rpc);
+		await watcher.importAddress("bc1qlegacy");
+
+		expect(rpc).toHaveBeenCalledWith("importaddress", ["bc1qlegacy", "", false]);
+	});
+
+	it("works with different chain configs (LTC, DOGE)", async () => {
+		const rpc = vi.fn<RpcCall>().mockImplementation(async (method) => {
+			if (method === "listreceivedbyaddress") {
+				return [{ address: "ltc1qtest", amount: 0.5, confirmations: 6, txids: ["ltctx1"] }];
+			}
+			if (method === "gettransaction") {
+				return {
+					details: [{ address: "ltc1qtest", amount: 0.5, category: "receive" }],
+					confirmations: 6,
+				};
+			}
+			return null;
+		});
+
+		const { watcher } = createTestWatcher(rpc, { token: "LTC", chain: "litecoin", confirmations: 6 });
+		watcher.setWatchedAddresses(["ltc1qtest"]);
+
+		const events = await watcher.poll();
+		expect(events).toHaveLength(1);
+		expect(events[0]!.chain).toBe("litecoin");
+		expect(events[0]!.token).toBe("LTC");
+	});
+
+	it("skips entries without a receive category detail", async () => {
+		const rpc = vi.fn<RpcCall>().mockImplementation(async (method) => {
+			if (method === "listreceivedbyaddress") {
+				return [{ address: "bc1qtest", amount: 1.0, confirmations: 6, txids: ["tx7"] }];
+			}
+			if (method === "gettransaction") {
+				return {
+					details: [{ address: "bc1qtest", amount: 1.0, category: "send" }],
+					confirmations: 6,
+				};
+			}
+			return null;
+		});
+
+		const { watcher } = createTestWatcher(rpc);
+		watcher.setWatchedAddresses(["bc1qtest"]);
+
+		const events = await watcher.poll();
+		expect(events).toEqual([]);
+	});
+
+	it("init loads cursor from store", async () => {
+		const rpc = vi.fn();
+		const { watcher, cursorStore } = createTestWatcher(rpc);
+		cursorStore._cursors.set("bitcoin:BTC", 42);
+
+		await watcher.init();
+		expect(watcher.getCursor()).toBe(42);
+	});
+});