@hardkas/toolkit 0.11.2-alpha → 0.11.4-alpha

package/test/snapshot.test.ts

@@ -1,99 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { SnapshotToolkit } from '../src/snapshot/index.js';
-import { JobsToolkit } from '../src/jobs.js';
-import fs from 'fs-extra';
-import path from 'path';
-
-describe('SnapshotToolkit (Time Travel)', () => {
-    let snapshots: SnapshotToolkit;
-    let jobs: JobsToolkit;
-
-    const testDir = path.join(process.cwd(), '.test-snapshots');
-
-    beforeEach(async () => {
-        await fs.ensureDir(testDir);
-        snapshots = SnapshotToolkit.open({ backend: 'filesystem', dir: testDir });
-        jobs = JobsToolkit.open({ storePath: path.join(testDir, 'jobs.json') });
-        snapshots.register('jobs', jobs);
-    });
-
-    afterEach(async () => {
-        await fs.remove(testDir);
-    });
-
-    it('should save, mutate, and restore state', async () => {
-        // State 1
-        await jobs.enqueue('payment', { to: 'alice' });
-        const s1 = await snapshots.create('state1');
-
-        let job1 = await jobs.getJob((await jobs.snapshot() as any)[Object.keys(await jobs.snapshot())[0]].id);
-        expect(job1).toBeDefined();
-
-        // Mutate State 2
-        await jobs.enqueue('payment', { to: 'bob' });
-        
-        let stateKeys = Object.keys(await jobs.snapshot());
-        expect(stateKeys.length).toBe(2);
-
-        // Restore State 1
-        await snapshots.restore(s1.snapshotId);
-
-        // Verify restored
-        stateKeys = Object.keys(await jobs.snapshot());
-        expect(stateKeys.length).toBe(1); // bob's job is gone
-
-        // Branch from State 1
-        const b1 = await snapshots.branch(s1.snapshotId, 'experiment-a');
-        expect(b1.name).toBe('experiment-a');
-    });
-
-    it('should handle partial restore failures gracefully', async () => {
-        // Enqueue some initial jobs
-        await jobs.enqueue('payment', { to: 'alice' });
-        const base = await snapshots.create('base');
-
-        // Register a malicious participant that fails on restore
-        const failingParticipant = {
-            snapshot: async () => ({ bad: 'state' }),
-            restore: async () => { throw new Error('Simulated restore failure'); },
-            reload: async () => {}
-        };
-        snapshots.register('failing', failingParticipant);
-        const badSnapshot = await snapshots.create('bad');
-
-        // Restore should throw and mention the participant
-        await expect(snapshots.restore(badSnapshot.snapshotId)).rejects.toThrow(/Failed to restore participant 'failing'/);
-    });
-
-    it('should fail if participant is missing on restore', async () => {
-        await jobs.enqueue('payment', { to: 'alice' });
-        const base = await snapshots.create('base');
-
-        // Unregister a participant by creating a new snapshots instance
-        const newSnapshots = SnapshotToolkit.open({ backend: 'filesystem', dir: testDir });
-        // Didn't register 'jobs' this time
-
-        await expect(newSnapshots.restore(base.snapshotId)).rejects.toThrow(/not registered/);
-    });
-
-    it('should generate deterministic diffs and valid filesystem manifests', async () => {
-        await jobs.enqueue('payment', { to: 'alice' });
-        const s1 = await snapshots.create('s1');
-
-        await jobs.enqueue('payment', { to: 'bob' });
-        const s2 = await snapshots.create('s2');
-
-        const diff = await snapshots.diff(s1.snapshotId, s2.snapshotId);
-        expect(diff).toHaveProperty('jobs');
-        
-        // Assert filesystem manifest created properly
-        const manifestPath = path.join(testDir, s1.snapshotId, 'manifest.json');
-        expect(await fs.pathExists(manifestPath)).toBe(true);
-
-        const manifest = await fs.readJson(manifestPath);
-        expect(manifest.schema).toBe('hardkas.snapshot.v1');
-        expect(manifest.backend).toBe('filesystem');
-        expect(manifest.participants).toContain('jobs');
-        expect(manifest.stateHashes).toHaveProperty('jobs');
-    });
-});

package/test/toolkit.test.ts

@@ -1,140 +0,0 @@
-import { describe, it, expect, beforeAll, afterAll } from 'vitest';
-import { WalletToolkit, PaymentToolkit, IndexerToolkit } from '../src/index.js';
-import * as fs from 'node:fs/promises';
-import * as path from 'node:path';
-
-describe('@hardkas/toolkit V1', () => {
-    const tmpDir = path.join(process.cwd(), '.test-toolkit');
-
-    beforeAll(async () => {
-        try { await fs.mkdir(tmpDir, { recursive: true }); } catch (e) {}
-    });
-
-    afterAll(async () => {
-        try { await fs.rm(tmpDir, { recursive: true, force: true }); } catch (e) {}
-    });
-
-    describe('WalletToolkit', () => {
-        it('should instantiate and return address', async () => {
-            const wallet = WalletToolkit.open('alice', { storePath: path.join(tmpDir, 'wallets.json') });
-            await wallet.create();
-            const addr = await wallet.address();
-            expect(addr).toBeDefined();
-            expect(typeof addr).toBe('string');
-            expect(addr.startsWith('kaspasim:') || addr.startsWith('kaspa:')).toBe(true);
-        });
-
-        it('should estimate fee and plan send', async () => {
-            const wallet = WalletToolkit.open('alice', { storePath: path.join(tmpDir, 'wallets.json') });
-            // Mock the internal walletQuery for the test
-            (wallet as any).walletQuery.getUtxos = async () => ({ ok: true, utxos: {} });
-            
-            await wallet.create(); // Create it so we can fetch it
-            
-            // This is a facade test, we just want to ensure it doesn't crash on wiring
-            const utxos = await wallet.utxos.list();
-            expect(Array.isArray(utxos)).toBe(true);
-            
-            // To test estimateFee, CoinSelector might throw if not enough funds, 
-            // but we at least know it wired up the query correctly.
-        });
-    });
-
-    describe('PaymentToolkit', () => {
-        it('should create invoice and receipt with persistence', async () => {
-            const pt = PaymentToolkit.openMerchant('store-1', { storePath: path.join(tmpDir, 'invoices.json') });
-            const inv = await pt.createInvoice({ amount: 150n, currency: 'KAS' });
-            expect(inv.id).toBeDefined();
-            expect(inv.uri).toContain('kaspa:store-1');
-            expect(inv.uri).toContain('amount=150');
-            expect(inv.status).toBe('pending');
-
-            const status = await pt.check(inv.id);
-            expect(status).toBe('pending');
-
-            // Simulate payment
-            await pt.simulatePay(inv.id);
-            const paidStatus = await pt.check(inv.id);
-            expect(paidStatus).toBe('paid');
-
-            const receipt = await pt.receipt(inv.id);
-            expect(receipt.schema).toBe('paymentReceipt.v1');
-            expect(receipt.merchantId).toBe('store-1');
-
-            const list = await pt.listInvoices();
-            expect(list.length).toBe(1);
-
-            const stats = await pt.stats();
-            expect(stats.totalInvoices).toBe(1);
-            expect(stats.paidInvoices).toBe(1);
-        });
-
-        it('should throw when requesting receipt for pending or non-existent invoice', async () => {
-            const pt = PaymentToolkit.openMerchant('store-err', { storePath: path.join(tmpDir, 'invoices-err.json') });
-            const inv = await pt.createInvoice({ amount: 150n, currency: 'KAS' });
-            
-            await expect(pt.receipt(inv.id)).rejects.toThrow('Invoice is not paid');
-            await expect(pt.receipt('non-existent')).rejects.toThrow('Invoice not found');
-        });
-
-        it('should allow creating invoice with amountSompi', async () => {
-            const pt = PaymentToolkit.openMerchant('store-sompi', { storePath: path.join(tmpDir, 'invoices-sompi.json') });
-            const inv = await pt.createInvoice({ amountSompi: 150000000n }); // 1.5 KAS
-            
-            expect(inv.amount).toBe(1n); // 150000000 / 100000000 = 1 (truncates)
-            expect(inv.uri).toContain('amount=1.5');
-        });
-    });
-
-    describe('JobsToolkit', () => {
-        it('should initialize and enqueue jobs', async () => {
-            const { JobsToolkit } = await import('../src/index.js');
-            const jobs = JobsToolkit.open({ storePath: path.join(tmpDir, 'jobs.json') });
-            jobs.registerHandler('test-job', async (ctx) => {
-                ctx.progress.update({ total: 10, processed: 10 });
-            });
-            const id = await jobs.enqueue('test-job', {});
-            expect(id).toBeDefined();
-            
-            // Allow a tick for async job to execute
-            await new Promise(r => setTimeout(r, 50));
-            
-            const job = await jobs.getJob(id);
-            expect(job).toBeDefined();
-            expect(job?.type).toBe('test-job');
-        });
-    });
-
-    describe('IndexerToolkit', () => {
-        it('should bind mock data to address watch and trigger handler', async () => {
-            const idx = await IndexerToolkit.open({ dataDir: tmpDir });
-            
-            let called = false;
-            await idx.watch('kaspa:store-1', async (evt) => {
-                called = true;
-            }); 
-            
-            // Trigger the internal subscriber handler manually since we don't have the timer easily accessible
-            const sub = (idx as any).subscriber;
-            const handler = Array.from(sub.activeIntervals.entries())[0]; 
-            // Actually the interval doesn't trigger unless we mock options.source.getUtxos, which is empty here.
-            // But we can verify it registers correctly.
-            await idx.watch(['kaspa:store-1', 'kaspa:store-2']); // should also work
-        });
-        it('should ingest and find artifacts', async () => {
-            const idx = IndexerToolkit.open({ dataDir: tmpDir });
-            
-            await idx.watch('kaspa:store-1'); // should just bind
-
-            await idx.ingestArtifact({
-                id: '123',
-                schema: 'test.v1',
-                tags: ['test:abc']
-            });
-
-            const found = await idx.findReceipts({ tags: ['test:abc'] });
-            expect(found.length).toBe(1);
-            expect(found[0].hash).toBe('123');
-        });
-    });
-});

package/tsconfig.json

@@ -1,9 +0,0 @@
-{
-  "extends": "../../tsconfig.base.json",
-  "compilerOptions": {
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "declaration": true
-  },
-  "include": ["src/**/*"]
-}

package/vitest.config.ts

@@ -1,8 +0,0 @@
-import { defineConfig } from 'vitest/config';
-
-export default defineConfig({
-  test: {
-    environment: 'node',
-    include: ['test/**/*.test.ts'],
-  }
-});