trac-msb 0.2.4 → 0.2.6

package/tests/acceptance/v1/tx-hashes/tx-hashes.test.mjs

@@ -0,0 +1,72 @@
+import request from "supertest"
+
+export const registerTxHashesTests = (context) => {
+    describe("GET /v1/tx-hashes", () => {
+        it("< 1000", async () => {
+            const res = await request(context.server).get("/v1/tx-hashes/1/1001")
+            expect(res.statusCode).toBe(200)
+            expect(res.body).toEqual({
+                hashes: expect.arrayContaining([
+                    expect.objectContaining({
+                        hash: expect.any(String),
+                        confirmed_length: expect.any(Number),
+                    })
+                ])
+            })
+        })
+
+        it("> 1000", async () => {
+            const res = await request(context.server).get("/v1/tx-hashes/1/1002")
+            expect(res.statusCode).toBe(400)
+        })
+
+        it("returns 400 for non-integer params", async () => {
+            const res = await request(context.server).get("/v1/tx-hashes/foo/bar")
+            expect(res.statusCode).toBe(400)
+            expect(res.body).toEqual({ error: "Params must be integer" })
+        })
+
+        it("returns 400 for negative params", async () => {
+            const res = await request(context.server).get("/v1/tx-hashes/-1/10")
+            expect(res.statusCode).toBe(400)
+            expect(res.body).toEqual({ error: "Params must be non-negative" })
+        })
+
+        it("returns 400 when end < start", async () => {
+            const res = await request(context.server).get("/v1/tx-hashes/10/5")
+            expect(res.statusCode).toBe(400)
+            expect(res.body).toEqual({ error: "endSignedLength must be greater than or equal to startSignedLength." })
+        })
+
+        it("accepts boundary at exactly MAX_SIGNED_LENGTH", async () => {
+            const res = await request(context.server).get("/v1/tx-hashes/1/1001")
+            expect(res.statusCode).toBe(200)
+        })
+
+        it("trims range to current confirmed length", async () => {
+            const confirmed = await request(context.server).get("/v1/confirmed-length")
+            expect(confirmed.statusCode).toBe(200)
+            const beyond = confirmed.body.confirmed_length + 50
+            const res = await request(context.server).get(`/v1/tx-hashes/0/${beyond}`)
+            expect(res.statusCode).toBe(200)
+            const hashes = res.body.hashes || []
+            // last item confirmed_length should not exceed current confirmed length
+            const maxReturned = hashes.reduce((max, { confirmed_length }) => Math.max(max, confirmed_length || 0), 0)
+            expect(maxReturned).toBeLessThanOrEqual(confirmed.body.confirmed_length)
+        })
+
+        it("returns empty hashes when no data in range", async () => {
+            const res = await request(context.server).get("/v1/tx-hashes/0/0")
+            expect(res.statusCode).toBe(200)
+            expect(res.body).toHaveProperty("hashes")
+            expect(Array.isArray(res.body.hashes)).toBe(true)
+        })
+
+        it("returns empty hashes when start equals end", async () => {
+            const res = await request(context.server).get("/v1/tx-hashes/5/5")
+            expect(res.statusCode).toBe(200)
+            expect(res.body).toHaveProperty("hashes")
+            expect(res.body.hashes).toEqual([])
+        })
+    })
+}

package/tests/acceptance/v1/tx-payloads-bulk/tx-payloads-bulk.test.mjs

@@ -0,0 +1,27 @@
+import request from "supertest"
+
+export const registerTxPayloadsBulkTests = (context) => {
+    describe("POST /v1/tx-payloads-bulk", () => {
+        it("returns payloads for requested hashes", async () => {
+            const result = await context.rpcMsb.state.confirmedTransactionsBetween(0, 40) // Arbitrary range that should contain valid entries
+            const hashes = result.map(({ hash }) => hash)
+
+            const payload = { hashes }
+
+            const res = await request(context.server)
+                .post("/v1/tx-payloads-bulk")
+                .set("Accept", "application/json")
+                .send(JSON.stringify(payload))
+
+            expect(res.statusCode).toBe(200)
+            expect(res.body).toMatchObject({
+                results: expect.arrayOf(
+                    expect.objectContaining({
+                        hash: expect.any(String),
+                    })
+                ),
+                missing: []
+            })
+        })
+    })
+}

package/tests/acceptance/v1/txv/txv.test.mjs

@@ -0,0 +1,11 @@
+import request from "supertest"
+
+export const registerTxvTests = (context) => {
+    describe("GET /v1/txv", () => {
+        it("returns txv hash", async () => {
+            const res = await request(context.server).get("/v1/txv")
+            expect(res.statusCode).toBe(200)
+            expect(res.body).toEqual({ txv: expect.stringMatching(/^[a-z0-9]{64}$/) })
+        })
+    })
+}

package/tests/acceptance/v1/unconfirmed-length/unconfirmed-length.test.mjs

@@ -0,0 +1,11 @@
+import request from "supertest"
+
+export const registerUnconfirmedLengthTests = (context) => {
+    describe("GET /v1/unconfirmed-length", () => {
+        it("returns unconfirmed length", async () => {
+            const res = await request(context.server).get("/v1/unconfirmed-length")
+            expect(res.statusCode).toBe(200)
+            expect(res.body).toEqual({ unconfirmed_length: expect.any(Number) })
+        })
+    })
+}

package/tests/helpers/StateNetworkFactory.js

@@ -0,0 +1,157 @@
+/**
+ * Lightweight factory for spinning up Autobase+State test networks.
+ *
+ * Each node gets:
+ *  - a Corestore/Autobase pair created via test/testHelpers/autobaseTestHelpers
+ *  - a PeerWallet (bootstrap uses the deterministic test mnemonic)
+ *  - a State instance wired to the same bootstrap key so we can plug its apply handler directly
+ *
+ * Tests can grab `network.adminBootstrap` (the first node) plus the rest from `network.peers`,
+ * call `await network.sync()` to replicate, and `await network.teardown()` in their cleanup hook.
+ */
+
+import State from '../../src/core/state/State.js';
+import {
+	create,
+	createStores,
+	replicateAndSync,
+	defaultOpenHyperbeeView,
+	createWallet,
+	seedIndexerList
+} from './autobaseTestHelpers.js';
+import {
+	AUTOBASE_VALUE_ENCODING,
+	ACK_INTERVAL
+} from '../../src/utils/constants.js';
+import { testKeyPair1 } from '../fixtures/apply.fixtures.js';
+
+export class StateNetworkFactory {
+	
+	static async create(options = {}) {
+		const factory = new StateNetworkFactory(options);
+		await factory.#initialize();
+		return factory;
+	}
+
+	#adminPeer = null;
+	#peers = [];
+	#bases = [];
+	#harness = createHarness();
+	#options;
+
+	constructor({
+		nodes = 2,
+		valueEncoding = AUTOBASE_VALUE_ENCODING,
+		stateOptions = {},
+		autobaseOptions = {},
+		open = defaultOpenHyperbeeView,
+		seedIndexers = true
+	} = {}) {
+		if (nodes < 1) throw new Error('StateNetworkFactory requires at least one node');
+		this.#options = {
+			nodes,
+			valueEncoding,
+			stateOptions,
+			autobaseOptions,
+			open,
+			seedIndexers
+		};
+	}
+
+	get adminBootstrap() {
+		return this.#adminPeer;
+	}
+
+	get peers() {
+		return this.#peers;
+	}
+
+	// Backwards compatibility
+	get bootstrap() {
+		return this.#adminPeer;
+	}
+
+	get nodes() {
+		return this.#peers;
+	}
+
+	async sync() {
+		await replicateAndSync(this.#bases);
+	}
+
+	async teardown() {
+		await this.#harness.cleanup();
+	}
+
+	async #initialize() {
+		const { nodes, valueEncoding, stateOptions, autobaseOptions, open, seedIndexers } = this.#options;
+
+		const stateStores = await createStores(nodes, this.#harness);
+		const { bases } = await create(nodes, this.#harness, {
+			apply: async () => {},
+			open,
+			valueEncoding,
+			ackInterval: ACK_INTERVAL,
+			bigBatches: false,
+			optimistic: false,
+			...autobaseOptions
+		});
+		this.#bases = bases;
+
+		await Promise.all(bases.map(base => base.ready()));
+
+		const bootstrapKey = bases[0].local.key;
+		const descriptors = [];
+
+		for (let i = 0; i < nodes; i++) {
+			const mnemonic = i === 0 ? testKeyPair1.mnemonic : null;
+			const wallet = await createWallet(mnemonic);
+			const state = new State(stateStores[i].session(), bootstrapKey, wallet, {
+				enable_tx_apply_logs: false,
+				enable_error_apply_logs: true,
+				...stateOptions
+			});
+
+			bases[i]._handlers.apply = state.applyHandler;
+			descriptors.push({
+				index: i,
+				name: bases[i].name,
+				base: bases[i],
+				state,
+				wallet
+			});
+		}
+
+		if (seedIndexers) {
+			for (const descriptor of descriptors) {
+				seedIndexerList(descriptor.base, [bootstrapKey]);
+			}
+		}
+
+		this.#adminPeer = descriptors[0];
+		this.#peers = descriptors;
+	}
+}
+
+export async function setupStateNetwork(options = {}) {
+	return StateNetworkFactory.create(options);
+}
+
+function createHarness() {
+	const teardowns = [];
+	return {
+		teardown(fn, { order = 0 } = {}) {
+			teardowns.push({ fn, order });
+		},
+		async cleanup() {
+			const sorted = teardowns.sort((a, b) => b.order - a.order);
+			for (const { fn } of sorted) {
+				try {
+					await fn();
+				} catch (err) {
+					console.error('teardown failed', err);
+				}
+			}
+		}
+	};
+}

package/tests/helpers/autobaseTestHelpers.js

@@ -0,0 +1,369 @@
+// The code below originates from the holepunch/autobase repository (https://github.com/holepunchto/autobase)
+// License: Apache 2.0
+// The holepunch team has granted permission to reuse this code in the Trac Systems project.
+// Huge thanks to the holepunch team for their work and support!
+import path from 'path';
+import Corestore from 'corestore';
+import Autobase from 'autobase';
+import Hyperbee from 'hyperbee';
+import b4a from 'b4a';
+import PeerWallet from 'trac-wallet';
+import { blake3Hash } from '../../src/utils/crypto.js';
+import {
+	ACK_INTERVAL,
+	AUTOBASE_VALUE_ENCODING,
+	HYPERBEE_KEY_ENCODING,
+	HYPERBEE_VALUE_ENCODING,
+	TRAC_NAMESPACE
+} from '../../src/utils/constants.js';
+
+const argv = typeof globalThis.Bare !== 'undefined' ? globalThis.Bare.argv : process.argv;
+
+export const encryptionKey = argv?.includes('--encrypt-all')
+	? b4a.alloc(32).fill('autobase-encryption-test')
+	: undefined;
+
+export async function createStores(n, t, opts = {}) {
+	const storage = opts.storage || (() => tmpDir(t));
+	const offset = opts.offset || 0;
+
+	const stores = [];
+	for (let i = offset; i < n + offset; i++) {
+		const primaryKey = Buffer.alloc(32, i);
+		const globalCache = opts.globalCache || null;
+		const dir = await storage();
+		stores.push(new Corestore(dir, { primaryKey, encryptionKey, globalCache }));
+	}
+
+	t.teardown(async () => {
+		for (const store of stores) {
+			try {
+				await store.close();
+			} catch (err) {
+				console.error('corestore close failed', err);
+			}
+		}
+	}, { order: 2 });
+	return stores;
+}
+
+export async function create(n, t, opts = {}) {
+	const stores = await createStores(n, t, opts);
+	const bases = [createBase(stores[0], null, t, opts)];
+	await bases[0].ready();
+	bases[0].name = 'a';
+
+	if (n === 1) return { stores, bases };
+
+	for (let i = 1; i < n; i++) {
+		const base = createBase(stores[i], bases[0].local.key, t, opts);
+		await base.ready();
+		base.name = String.fromCharCode('a'.charCodeAt(0) + i);
+		bases.push(base);
+	}
+
+	return { stores, bases };
+}
+
+export function createBase(store, key, t, opts = {}) {
+	const {
+		open = defaultOpenHyperbeeView,
+		valueEncoding = AUTOBASE_VALUE_ENCODING,
+		ackInterval = ACK_INTERVAL,
+		bigBatches = false,
+		optimistic = false,
+		...rest
+	} = opts;
+
+	const base = new Autobase(store.session(), key, {
+		open,
+		close: undefined,
+		valueEncoding,
+		ackInterval,
+		bigBatches,
+		optimistic,
+		ackThreshold: 0,
+		encryptionKey,
+		fastForward: false,
+		...rest
+	});
+	
+	base.on('error', err => {
+		if (err?.code === 'SESSION_CLOSED') return;
+		console.error('autobase error', err);
+	});
+
+	if (opts.maxSupportedVersion !== undefined) {
+		base.maxSupportedVersion = opts.maxSupportedVersion;
+	}
+
+	t.teardown(async () => {
+		try {
+			await base.advance();
+		} catch (err) {
+			if (err?.code !== 'SESSION_CLOSED') {
+				console.error('base advance failed', err);
+			}
+		}
+		try {
+			await base.close();
+		} catch (err) {
+			console.error('base close failed', err);
+		}
+	}, { order: 1 });
+	return base;
+}
+
+export function defaultOpenHyperbeeView(store) {
+	return new Hyperbee(store.get(TRAC_NAMESPACE), {
+		extension: false,
+		keyEncoding: HYPERBEE_KEY_ENCODING,
+		valueEncoding: HYPERBEE_VALUE_ENCODING
+	});
+}
+
+export async function createWallet(mnemonic = null) {
+	const wallet = new PeerWallet();
+	await wallet.generateKeyPair(mnemonic ?? undefined);
+	return wallet;
+}
+
+export function seedIndexerList(base, keys) {
+	base.system.indexers = keys.map(key => ({ key, length: 0 }));
+	if (base.system._indexerMap instanceof Map) {
+		for (const key of keys) {
+			base.system._indexerMap.set(b4a.toString(key, 'hex'), { key, length: 0 });
+		}
+	}
+}
+
+export const seedBootstrapIndexer = (network) => {
+	const bootstrapPeer = network.adminBootstrap ?? network.bootstrap;
+	const key = bootstrapPeer.base.local.key;
+	for (const { base } of network.nodes) {
+		seedIndexerList(base, [key]);
+	}
+};
+
+export async function replicateAndSync(bases, opts) {
+	const done = replicate(bases);
+	await sync(bases, opts);
+	await done();
+}
+
+export async function sync(bases, { checkHash = true } = {}) {
+	for (const base of bases) {
+		await base.update();
+	}
+
+	if (bases.length === 1) return;
+
+	return new Promise((resolve, reject) => {
+		let done = false;
+		let checks = 0;
+
+		for (const base of bases) {
+			base.on('update', check);
+			base.on('error', shutdown);
+		}
+
+		check();
+
+		async function check() {
+			checks++;
+			for (const base of bases) {
+				if (base.interrupted) return shutdown(new Error('base was interrupted, reason at base.interrupted'));
+			}
+			if (!(await areSame(checkHash))) return maybeShutdown();
+			for (const base of bases) {
+				await base.update();
+			}
+			if (!(await areSame(checkHash))) return maybeShutdown();
+			shutdown();
+		}
+
+		function maybeShutdown() {
+			if (done) return shutdown();
+			checks--;
+		}
+
+		async function areSame(checkHash) {
+			return sameHeadsAcross(bases) && await sameHash(bases, checkHash);
+		}
+
+		function shutdown(err) {
+			checks--;
+			done = true;
+			if (checks !== 0 && !err) return;
+
+			for (const base of bases) {
+				base.off('update', check);
+				base.off('error', shutdown);
+			}
+
+			if (err) reject(err);
+			else resolve();
+		}
+	});
+}
+
+function replicate(bases) {
+	const streams = [];
+	const missing = bases.slice();
+
+	while (missing.length) {
+		const a = missing.pop();
+		for (const b of missing) {
+			const s1 = a.replicate(true);
+			const s2 = b.replicate(false);
+
+			s1.on('error', err => {
+				if (err.code) console.log('autobase replicate error:', err.stack);
+			});
+			s2.on('error', err => {
+				if (err.code) console.log('autobase replicate error:', err.stack);
+			});
+
+			s1.pipe(s2).pipe(s1);
+			streams.push(s1, s2);
+		}
+	}
+
+	return close;
+
+	function close() {
+		return Promise.all(streams.map(s => {
+			s.destroy();
+			return new Promise(resolve => s.on('close', resolve));
+		}));
+	}
+}
+
+function sameHeadsAcross(bases) {
+	const first = bases[0];
+	for (let i = 1; i < bases.length; i++) {
+		if (!sameHeads(first, bases[i])) return false;
+	}
+	return true;
+}
+
+async function sameHash(bases, check) {
+	if (!check) return true;
+	const first = bases[0];
+	const h1 = await first.hash();
+	for (let i = 1; i < bases.length; i++) {
+		if (bases[i].signedLength !== first.signedLength) return false;
+		const h2 = await bases[i].hash();
+		if (!b4a.equals(h1, h2)) return false;
+	}
+	return true;
+}
+
+function sameHeads(a, b) {
+	if (a.updating || b.updating) return false;
+
+	const h1 = a.heads();
+	const h2 = b.heads();
+
+	if (h1.length !== h2.length) return false;
+
+	for (let i = 0; i < h1.length; i++) {
+		const h1i = h1[i];
+		const h2i = h2[i];
+
+		if (!b4a.equals(h1i.key, h2i.key)) return false;
+		if (h1i.length !== h2i.length) return false;
+	}
+
+	return true;
+}
+
+export function eventFlush() {
+	return new Promise(resolve => setImmediate(resolve));
+}
+
+export function deriveIndexerSequenceState(base) {
+	const indexers = base.system?.indexers || [];
+	const buffers = indexers
+		.map(entry => entry?.key)
+		.filter(key => key && key.length > 0);
+	const concatenated = buffers.length > 0 ? b4a.concat(buffers) : b4a.alloc(0);
+	return blake3Hash(concatenated);
+}
+
+let osModule;
+let fsPromises;
+
+async function ensureEnvReady() {
+	if (osModule && fsPromises) return;
+
+	if (typeof globalThis.Bare !== 'undefined') {
+		const bareOs = await import('bare-os');
+		osModule = bareOs.default || bareOs;
+
+		const bareFs = await import('bare-fs');
+		const resolved = bareFs.default || bareFs;
+		fsPromises = resolved.promises;
+	} else {
+		const nodeOs = await import('os');
+		osModule = nodeOs.default || nodeOs;
+
+		const nodeFs = await import('fs/promises');
+		fsPromises = nodeFs.default || nodeFs;
+	}
+}
+
+async function tmpDir(t) {
+	await ensureEnvReady();
+	const prefix = path.join(osModule.tmpdir(), 'msb-autobase-');
+	const dir = await createTempDir(prefix);
+	t.teardown(() => cleanupTempDir(dir), { order: 3 });
+	return dir;
+}
+
+async function createTempDir(prefix) {
+	if (typeof fsPromises.mkdtemp === 'function') {
+		return fsPromises.mkdtemp(prefix);
+	}
+	const uniqueDir = `${prefix}${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
+	await fsPromises.mkdir(uniqueDir, { recursive: true });
+	return uniqueDir;
+}
+
+async function cleanupTempDir(dir) {
+	if (!fsPromises) return;
+
+	try {
+		if (typeof fsPromises.rm === 'function') {
+			await fsPromises.rm(dir, { recursive: true, force: true });
+		} else if (typeof fsPromises.rmdir === 'function') {
+			await removeRecursively(dir);
+		}
+	} catch (err) {
+		if (err?.code === 'ENOENT') return;
+		// Windows sometimes keeps LOCK files open briefly. Ignore busy/permission errors during teardown.
+		if (err?.code === 'EBUSY' || err?.code === 'EPERM') return;
+		throw err;
+	}
+}
+
+async function removeRecursively(target) {
+	let stats;
+	try {
+		stats = await fsPromises.lstat(target);
+	} catch (err) {
+		if (err?.code === 'ENOENT') return;
+		throw err;
+	}
+
+	if (!stats.isDirectory()) {
+		await fsPromises.unlink(target);
+		return;
+	}
+
+	const entries = await fsPromises.readdir(target);
+	for (const entry of entries) {
+		await removeRecursively(path.join(target, entry));
+	}
+	await fsPromises.rmdir(target);
+}

package/tests/helpers/createTestSignature.js

@@ -0,0 +1,12 @@
+import PeerWallet from 'trac-wallet';
+
+export async function createSignature(payloadBuffer) {
+    const wallet = new PeerWallet();
+    await wallet.generateKeyPair();
+    const signature = wallet.sign(payloadBuffer);
+    return { signature, wallet };
+}
+
+export default {
+    createSignature
+};