@wopr-network/crypto-plugins 1.0.1

package/src/__tests__/registry.test.ts

@@ -0,0 +1,91 @@
+import type { IChainPlugin } from "@wopr-network/platform-core/crypto-plugin";
+import { describe, expect, it } from "vitest";
+import { bitcoinPlugin, dogecoinPlugin, evmPlugin, litecoinPlugin, solanaPlugin, tronPlugin } from "../index.js";
+
+const allPlugins: IChainPlugin[] = [evmPlugin, bitcoinPlugin, litecoinPlugin, dogecoinPlugin, tronPlugin, solanaPlugin];
+
+/** Plugin IDs that have real createWatcher implementations. */
+const implementedIds = new Set(["evm", "bitcoin", "litecoin", "dogecoin", "tron", "solana"]);
+
+/** Plugin IDs that have real createSweeper implementations (don't throw on construction). */
+const sweeperImplementedIds = new Set(["solana"]);
+
+/** Plugins that still have stub watcher/sweeper implementations. */
+const stubPlugins = allPlugins.filter((p) => !implementedIds.has(p.pluginId));
+
+/** Plugins with real createWatcher implementations. */
+const implementedPlugins = allPlugins.filter((p) => implementedIds.has(p.pluginId));
+
+describe("Plugin registry", () => {
+	it("all plugins have unique pluginIds", () => {
+		const ids = allPlugins.map((p) => p.pluginId);
+		expect(new Set(ids).size).toBe(ids.length);
+	});
+
+	it("all plugins implement IChainPlugin shape", () => {
+		for (const plugin of allPlugins) {
+			expect(plugin.pluginId).toBeTypeOf("string");
+			expect(plugin.supportedCurve).toMatch(/^(secp256k1|ed25519)$/);
+			expect(plugin.encoders).toBeTypeOf("object");
+			expect(plugin.createWatcher).toBeTypeOf("function");
+			expect(plugin.createSweeper).toBeTypeOf("function");
+			expect(plugin.version).toBeTypeOf("number");
+		}
+	});
+
+	it("secp256k1 plugins: evm, bitcoin, litecoin, dogecoin, tron", () => {
+		const secp = allPlugins.filter((p) => p.supportedCurve === "secp256k1");
+		expect(secp.map((p) => p.pluginId).sort()).toEqual(["bitcoin", "dogecoin", "evm", "litecoin", "tron"]);
+	});
+
+	it("ed25519 plugins: solana", () => {
+		const ed = allPlugins.filter((p) => p.supportedCurve === "ed25519");
+		expect(ed.map((p) => p.pluginId)).toEqual(["solana"]);
+	});
+
+	it("stub createWatcher throws Not implemented", () => {
+		for (const plugin of stubPlugins) {
+			expect(() => plugin.createWatcher({} as never)).toThrow("Not implemented");
+		}
+	});
+
+	it("implemented createWatcher does not throw", () => {
+		for (const plugin of implementedPlugins) {
+			expect(() => plugin.createWatcher({} as never)).not.toThrow();
+		}
+	});
+
+	it("stub createSweeper throws Not implemented", () => {
+		const sweeperStubs = allPlugins.filter((p) => !sweeperImplementedIds.has(p.pluginId));
+		for (const plugin of sweeperStubs) {
+			expect(() => plugin.createSweeper({} as never)).toThrow("Not implemented");
+		}
+	});
+
+	it("implemented createSweeper does not throw", () => {
+		const sweeperImpl = allPlugins.filter((p) => sweeperImplementedIds.has(p.pluginId));
+		for (const plugin of sweeperImpl) {
+			expect(() => plugin.createSweeper({} as never)).not.toThrow();
+		}
+	});
+
+	it("evm plugin has evm encoder", () => {
+		expect(evmPlugin.encoders).toHaveProperty("evm");
+		expect(evmPlugin.encoders.evm.encodingType()).toBe("evm");
+	});
+
+	it("solana plugin has base58-solana encoder", () => {
+		expect(solanaPlugin.encoders).toHaveProperty("base58-solana");
+		expect(solanaPlugin.encoders["base58-solana"].encodingType()).toBe("base58-solana");
+	});
+
+	it("can build a registry map from plugins", () => {
+		const registry = new Map<string, IChainPlugin>();
+		for (const plugin of allPlugins) {
+			registry.set(plugin.pluginId, plugin);
+		}
+		expect(registry.size).toBe(6);
+		expect(registry.get("evm")).toBe(evmPlugin);
+		expect(registry.get("solana")).toBe(solanaPlugin);
+	});
+});

package/src/__tests__/rpc.test.ts

@@ -0,0 +1,36 @@
+import { describe, expect, it } from "vitest";
+
+import { parseRpcUrl } from "../shared/utxo/rpc.js";
+
+describe("parseRpcUrl", () => {
+	it("extracts credentials from URL with embedded auth", () => {
+		const result = parseRpcUrl("http://myuser:mypass@localhost:8332");
+		expect(result.rpcUser).toBe("myuser");
+		expect(result.rpcPassword).toBe("mypass");
+		expect(result.rpcUrl).toBe("http://localhost:8332");
+	});
+
+	it("handles URL-encoded credentials", () => {
+		const result = parseRpcUrl("http://user%40name:p%40ss@host:8332");
+		expect(result.rpcUser).toBe("user@name");
+		expect(result.rpcPassword).toBe("p@ss");
+	});
+
+	it("returns empty credentials for URL without auth", () => {
+		const result = parseRpcUrl("http://localhost:8332");
+		expect(result.rpcUser).toBe("");
+		expect(result.rpcPassword).toBe("");
+		expect(result.rpcUrl).toBe("http://localhost:8332");
+	});
+
+	it("strips trailing slash from parsed URL", () => {
+		const result = parseRpcUrl("http://user:pass@localhost:8332/");
+		expect(result.rpcUrl).toBe("http://localhost:8332");
+	});
+
+	it("handles non-URL strings gracefully", () => {
+		const result = parseRpcUrl("not-a-url");
+		expect(result.rpcUrl).toBe("not-a-url");
+		expect(result.rpcUser).toBe("");
+	});
+});

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

@@ -0,0 +1,103 @@
+import { ed25519 } from "@noble/curves/ed25519.js";
+import { describe, expect, it } from "vitest";
+import { base58Encode, SolanaAddressEncoder } from "../solana/encoder.js";
+
+describe("SolanaAddressEncoder", () => {
+	const encoder = new SolanaAddressEncoder();
+
+	it("encodingType returns base58-solana", () => {
+		expect(encoder.encodingType()).toBe("base58-solana");
+	});
+
+	it("encodes a known 32-byte pubkey to correct Base58 address", () => {
+		// All-ones pubkey (32 bytes of 0x01)
+		const pubkey = new Uint8Array(32).fill(1);
+		const address = encoder.encode(pubkey, {});
+		// Base58 encoding of 32 bytes of 0x01
+		expect(typeof address).toBe("string");
+		expect(address.length).toBeGreaterThanOrEqual(32);
+		expect(address.length).toBeLessThanOrEqual(44);
+	});
+
+	it("produces deterministic addresses", () => {
+		const pubkey = new Uint8Array(32);
+		pubkey[31] = 42;
+		const a1 = encoder.encode(pubkey, {});
+		const a2 = encoder.encode(pubkey, {});
+		expect(a1).toBe(a2);
+	});
+
+	it("rejects non-32-byte input", () => {
+		expect(() => encoder.encode(new Uint8Array(20), {})).toThrow("32-byte");
+		expect(() => encoder.encode(new Uint8Array(33), {})).toThrow("32-byte");
+		expect(() => encoder.encode(new Uint8Array(0), {})).toThrow("32-byte");
+	});
+
+	it("encodes all-zero pubkey with leading 1s", () => {
+		const pubkey = new Uint8Array(32); // all zeros
+		const address = encoder.encode(pubkey, {});
+		// Base58 encodes leading zero bytes as '1'
+		expect(address.startsWith("1")).toBe(true);
+	});
+
+	it("derives correct address from Ed25519 seed 0x00...01", () => {
+		// Create a 32-byte seed with last byte = 1
+		const seed = new Uint8Array(32);
+		seed[31] = 1;
+
+		// Derive Ed25519 public key from private key (seed)
+		const publicKey = ed25519.getPublicKey(seed);
+		expect(publicKey.length).toBe(32);
+
+		// Encode as Solana address
+		const address = encoder.encode(publicKey, {});
+
+		// Verify it's a valid Base58 string
+		expect(address).toMatch(/^[1-9A-HJ-NP-Za-km-z]+$/);
+		expect(address.length).toBeGreaterThanOrEqual(32);
+		expect(address.length).toBeLessThanOrEqual(44);
+
+		// The address should be the Base58 of the raw pubkey — verify round-trip
+		const reencoded = base58Encode(publicKey);
+		expect(address).toBe(reencoded);
+	});
+
+	it("derives correct address for well-known Ed25519 test vector", () => {
+		// Seed = 32 bytes of 0x00...01
+		const seed = new Uint8Array(32);
+		seed[31] = 1;
+
+		const publicKey = ed25519.getPublicKey(seed);
+
+		// The Ed25519 public key for private key [0..0, 1] is a known value.
+		// The Solana address is just the Base58 of this 32-byte key.
+		const address = encoder.encode(publicKey, {});
+
+		// Ed25519 pubkey for seed 0x00..01 = 4cb5abf6ad79fbf5abbccafcc269d85cd2651ed4b885b5869f241aedf0a5ba29
+		// (this is the compressed Y coordinate of the point)
+		const expectedPubkeyHex = "4cb5abf6ad79fbf5abbccafcc269d85cd2651ed4b885b5869f241aedf0a5ba29";
+		const expectedPubkey = new Uint8Array(32);
+		for (let i = 0; i < 32; i++) {
+			expectedPubkey[i] = Number.parseInt(expectedPubkeyHex.slice(i * 2, i * 2 + 2), 16);
+		}
+		expect(publicKey).toEqual(expectedPubkey);
+
+		// Now verify the Base58 encoding of this pubkey
+		const expectedAddress = base58Encode(expectedPubkey);
+		expect(address).toBe(expectedAddress);
+	});
+
+	it("base58Encode handles various byte patterns", () => {
+		// Single byte
+		const single = new Uint8Array([0xff]);
+		const encoded = base58Encode(single);
+		expect(encoded).toBe("5Q");
+
+		// Empty-ish: all zeros should give all '1's
+		const zeros = new Uint8Array(3);
+		expect(base58Encode(zeros)).toBe("111");
+
+		// Known value: [1] should give "2"
+		expect(base58Encode(new Uint8Array([1]))).toBe("2");
+	});
+});

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

@@ -0,0 +1,316 @@
+import { describe, expect, it, vi } from "vitest";
+import type { SolanaTransaction } from "../solana/types.js";
+import { SolanaWatcher } from "../solana/watcher.js";
+
+/** Create a minimal mock WatcherOpts. */
+function createMockOpts(rpcResponses: Map<string, unknown>) {
+	// Override global fetch to return mocked RPC responses
+	const mockFetch = vi.fn(async (_url: string | URL | Request, init?: RequestInit) => {
+		const body = JSON.parse((init?.body as string) ?? "{}") as { method: string; id: number };
+		const result = rpcResponses.get(body.method);
+		return new Response(JSON.stringify({ jsonrpc: "2.0", id: body.id, result }), {
+			status: 200,
+			headers: { "Content-Type": "application/json" },
+		});
+	});
+
+	// biome-ignore lint/suspicious/noExplicitAny: test mock override
+	(globalThis as any).fetch = mockFetch;
+
+	return {
+		rpcUrl: "http://localhost:8899",
+		rpcHeaders: {},
+		oracle: { getPrice: vi.fn().mockResolvedValue({ priceMicros: 150_000_000 }) },
+		cursorStore: {
+			get: vi.fn().mockResolvedValue(null),
+			save: vi.fn().mockResolvedValue(undefined),
+			getConfirmationCount: vi.fn().mockResolvedValue(null),
+			saveConfirmationCount: vi.fn().mockResolvedValue(undefined),
+		},
+		token: "SOL",
+		chain: "solana",
+		decimals: 9,
+		confirmations: 1,
+		_mockFetch: mockFetch,
+	};
+}
+
+describe("SolanaWatcher", () => {
+	it("initializes with cursor from store", async () => {
+		const rpcResponses = new Map();
+		const opts = createMockOpts(rpcResponses);
+		opts.cursorStore.get = vi.fn().mockResolvedValue(500);
+
+		const watcher = new SolanaWatcher(opts);
+		await watcher.init();
+		expect(watcher.getCursor()).toBe(500);
+	});
+
+	it("returns empty when no watched addresses", async () => {
+		const rpcResponses = new Map();
+		const opts = createMockOpts(rpcResponses);
+
+		const watcher = new SolanaWatcher(opts);
+		await watcher.init();
+		const events = await watcher.poll();
+		expect(events).toEqual([]);
+	});
+
+	it("returns empty when stopped", async () => {
+		const rpcResponses = new Map();
+		const opts = createMockOpts(rpcResponses);
+
+		const watcher = new SolanaWatcher(opts);
+		await watcher.init();
+		watcher.setWatchedAddresses(["SomeAddress111111111111111111111111111111111"]);
+		watcher.stop();
+		const events = await watcher.poll();
+		expect(events).toEqual([]);
+	});
+
+	it("detects native SOL transfer to watched address", async () => {
+		const watchedAddr = "ReceiverAddr1111111111111111111111111111111";
+		const senderAddr = "SenderAddr11111111111111111111111111111111";
+
+		const mockTx: SolanaTransaction = {
+			slot: 100,
+			blockTime: 1700000000,
+			meta: {
+				err: null,
+				fee: 5000,
+				preBalances: [2_000_000_000, 500_000_000],
+				postBalances: [1_000_000_000, 1_500_000_000],
+			},
+			transaction: {
+				message: {
+					accountKeys: [senderAddr, watchedAddr],
+					instructions: [{ programIdIndex: 0, accounts: [0, 1], data: "" }],
+				},
+				signatures: ["sig123abc"],
+			},
+		};
+
+		const rpcResponses = new Map<string, unknown>();
+		rpcResponses.set("getSignaturesForAddress", [
+			{
+				signature: "sig123abc",
+				slot: 100,
+				err: null,
+				memo: null,
+				blockTime: 1700000000,
+				confirmationStatus: "finalized",
+			},
+		]);
+		rpcResponses.set("getTransaction", mockTx);
+
+		const opts = createMockOpts(rpcResponses);
+		const watcher = new SolanaWatcher(opts);
+		await watcher.init();
+		watcher.setWatchedAddresses([watchedAddr]);
+
+		const events = await watcher.poll();
+		expect(events).toHaveLength(1);
+		expect(events[0].txHash).toBe("sig123abc");
+		expect(events[0].to).toBe(watchedAddr);
+		expect(events[0].from).toBe(senderAddr);
+		expect(events[0].rawAmount).toBe("1000000000"); // 1 SOL increase
+		expect(events[0].chain).toBe("solana");
+		expect(events[0].token).toBe("SOL");
+		expect(events[0].blockNumber).toBe(100);
+	});
+
+	it("advances cursor for finalized transactions", async () => {
+		const watchedAddr = "ReceiverAddr1111111111111111111111111111111";
+
+		const mockTx: SolanaTransaction = {
+			slot: 200,
+			blockTime: 1700000000,
+			meta: {
+				err: null,
+				fee: 5000,
+				preBalances: [2_000_000_000, 0],
+				postBalances: [1_000_000_000, 1_000_000_000],
+			},
+			transaction: {
+				message: {
+					accountKeys: ["Sender1111111111111111111111111111111111111", watchedAddr],
+					instructions: [],
+				},
+				signatures: ["sig456def"],
+			},
+		};
+
+		const rpcResponses = new Map<string, unknown>();
+		rpcResponses.set("getSignaturesForAddress", [
+			{
+				signature: "sig456def",
+				slot: 200,
+				err: null,
+				memo: null,
+				blockTime: 1700000000,
+				confirmationStatus: "finalized",
+			},
+		]);
+		rpcResponses.set("getTransaction", mockTx);
+
+		const opts = createMockOpts(rpcResponses);
+		const watcher = new SolanaWatcher(opts);
+		await watcher.init();
+		watcher.setWatchedAddresses([watchedAddr]);
+
+		await watcher.poll();
+		expect(watcher.getCursor()).toBe(200);
+		expect(opts.cursorStore.save).toHaveBeenCalledWith("solana:solana:SOL", 200);
+	});
+
+	it("skips errored transactions", async () => {
+		const watchedAddr = "ReceiverAddr1111111111111111111111111111111";
+
+		const rpcResponses = new Map<string, unknown>();
+		rpcResponses.set("getSignaturesForAddress", [
+			{
+				signature: "errored-sig",
+				slot: 300,
+				err: { InstructionError: [0, "Custom"] },
+				memo: null,
+				blockTime: 1700000000,
+				confirmationStatus: "finalized",
+			},
+		]);
+
+		const opts = createMockOpts(rpcResponses);
+		const watcher = new SolanaWatcher(opts);
+		await watcher.init();
+		watcher.setWatchedAddresses([watchedAddr]);
+
+		const events = await watcher.poll();
+		expect(events).toEqual([]);
+	});
+
+	it("skips already-emitted confirmations", async () => {
+		const watchedAddr = "ReceiverAddr1111111111111111111111111111111";
+
+		const mockTx: SolanaTransaction = {
+			slot: 400,
+			blockTime: 1700000000,
+			meta: {
+				err: null,
+				fee: 5000,
+				preBalances: [2_000_000_000, 0],
+				postBalances: [1_000_000_000, 1_000_000_000],
+			},
+			transaction: {
+				message: {
+					accountKeys: ["Sender1111111111111111111111111111111111111", watchedAddr],
+					instructions: [],
+				},
+				signatures: ["sig-dup"],
+			},
+		};
+
+		const rpcResponses = new Map<string, unknown>();
+		rpcResponses.set("getSignaturesForAddress", [
+			{
+				signature: "sig-dup",
+				slot: 400,
+				err: null,
+				memo: null,
+				blockTime: 1700000000,
+				confirmationStatus: "finalized",
+			},
+		]);
+		rpcResponses.set("getTransaction", mockTx);
+
+		const opts = createMockOpts(rpcResponses);
+		// Already emitted at confirmation count 1
+		opts.cursorStore.getConfirmationCount = vi.fn().mockResolvedValue(1);
+
+		const watcher = new SolanaWatcher(opts);
+		await watcher.init();
+		watcher.setWatchedAddresses([watchedAddr]);
+
+		const events = await watcher.poll();
+		expect(events).toEqual([]);
+	});
+
+	it("detects SPL token transfer to watched address", async () => {
+		const watchedAddr = "ReceiverAddr1111111111111111111111111111111";
+		const senderAddr = "SenderAddr11111111111111111111111111111111";
+		const usdcMint = "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v";
+
+		const mockTx: SolanaTransaction = {
+			slot: 500,
+			blockTime: 1700000000,
+			meta: {
+				err: null,
+				fee: 5000,
+				preBalances: [2_000_000_000, 1_000_000],
+				postBalances: [1_995_000_000, 1_000_000],
+				preTokenBalances: [
+					{
+						accountIndex: 0,
+						mint: usdcMint,
+						uiTokenAmount: { amount: "10000000", decimals: 6, uiAmountString: "10.0" },
+						owner: senderAddr,
+					},
+					{
+						accountIndex: 1,
+						mint: usdcMint,
+						uiTokenAmount: { amount: "0", decimals: 6, uiAmountString: "0.0" },
+						owner: watchedAddr,
+					},
+				],
+				postTokenBalances: [
+					{
+						accountIndex: 0,
+						mint: usdcMint,
+						uiTokenAmount: { amount: "5000000", decimals: 6, uiAmountString: "5.0" },
+						owner: senderAddr,
+					},
+					{
+						accountIndex: 1,
+						mint: usdcMint,
+						uiTokenAmount: { amount: "5000000", decimals: 6, uiAmountString: "5.0" },
+						owner: watchedAddr,
+					},
+				],
+			},
+			transaction: {
+				message: {
+					accountKeys: [senderAddr, watchedAddr],
+					instructions: [],
+				},
+				signatures: ["spl-sig-789"],
+			},
+		};
+
+		const rpcResponses = new Map<string, unknown>();
+		rpcResponses.set("getSignaturesForAddress", [
+			{
+				signature: "spl-sig-789",
+				slot: 500,
+				err: null,
+				memo: null,
+				blockTime: 1700000000,
+				confirmationStatus: "finalized",
+			},
+		]);
+		rpcResponses.set("getTransaction", mockTx);
+
+		const opts = createMockOpts(rpcResponses);
+		// Configure as SPL token watcher
+		const splOpts = { ...opts, token: "USDC", contractAddress: usdcMint };
+
+		const watcher = new SolanaWatcher(splOpts);
+		await watcher.init();
+		watcher.setWatchedAddresses([watchedAddr]);
+
+		const events = await watcher.poll();
+		expect(events).toHaveLength(1);
+		expect(events[0].txHash).toBe("spl-sig-789");
+		expect(events[0].to).toBe(watchedAddr);
+		expect(events[0].from).toBe(senderAddr);
+		expect(events[0].rawAmount).toBe("5000000"); // 5 USDC
+		expect(events[0].token).toBe("USDC");
+	});
+});