@hivemind-os/collective-core 0.2.0

package/tests/events.test.ts

@@ -0,0 +1,202 @@
+import { randomUUID } from 'node:crypto';
+import { mkdir, rm } from 'node:fs/promises';
+import { resolve } from 'node:path';
+
+import { afterEach, describe, expect, it } from 'vitest';
+
+import { PaymentScheme, SqliteCursorStore, TaskStatus, parseRawEvent } from '../src/index.js';
+
+const createdPaths: string[] = [];
+const packageId = '0xpackage';
+
+afterEach(async () => {
+  await Promise.all(
+    createdPaths.splice(0).map((path) => rm(path, { recursive: true, force: true })),
+  );
+});
+
+async function createDbPath(): Promise<string> {
+  const dir = resolve(process.cwd(), '.test-data', randomUUID());
+  createdPaths.push(dir);
+  await mkdir(dir, { recursive: true });
+  return resolve(dir, 'cursor.sqlite');
+}
+
+describe('event parsing', () => {
+  it('parses AgentRegistered events', () => {
+    const event = parseRawEvent(
+      {
+        id: { txDigest: '0xtx', eventSeq: '0' },
+        packageId,
+        transactionModule: 'registry',
+        type: `${packageId}::registry::AgentRegistered`,
+        sender: '0xowner',
+        timestampMs: '1000',
+        parsedJson: {
+          card_id: '0xcard',
+          agent: '0xowner',
+          did: 'did:mesh:test',
+          name: 'Agent One',
+          description: 'Helpful agent',
+          capabilities: [
+            {
+              name: 'summarize',
+              description: 'Summarizes text',
+              version: '1.0.0',
+              price_mist: '100',
+              currency: 'MIST',
+            },
+          ],
+          endpoint: 'https://example.com',
+          active: true,
+          version: 1,
+          registered_at: 1000,
+          updated_at: 1000,
+        },
+        bcs: '',
+        bcsEncoding: 'base64',
+      },
+      packageId,
+    );
+
+    expect(event?.type).toBe('agent.registered');
+    if (event?.type !== 'agent.registered') {
+      throw new Error('Unexpected event type');
+    }
+    expect(event.agent.id).toBe('0xcard');
+    expect(event.agent.capabilities[0]?.name).toBe('summarize');
+  });
+
+  it('parses TaskPosted events', () => {
+    const event = parseRawEvent(
+      {
+        id: { txDigest: '0xtask', eventSeq: '1' },
+        packageId,
+        transactionModule: 'task',
+        type: `${packageId}::task::TaskPosted`,
+        sender: '0xrequester',
+        timestampMs: '2000',
+        parsedJson: {
+          task_id: '0xtask-id',
+          requester: '0xrequester',
+          provider: '0x0',
+          capability: 'summarize',
+          category: 'analysis',
+          input_blob_id: [105, 110, 112, 117, 116],
+          agreement_hash: [104, 97, 115, 104],
+          price: '1000',
+          status: 0,
+          dispute_window_ms: 5000,
+          expires_at: 10000,
+          created_at: 2000,
+        },
+        bcs: '',
+        bcsEncoding: 'base64',
+      },
+      packageId,
+    );
+
+    expect(event?.type).toBe('task.posted');
+    if (event?.type !== 'task.posted') {
+      throw new Error('Unexpected event type');
+    }
+    expect(event.task.id).toBe('0xtask-id');
+    expect(event.task.category).toBe('analysis');
+    expect(event.task.inputBlobId).toBe('input');
+    expect(event.task.status).toBe(TaskStatus.OPEN);
+  });
+
+  it('parses metered completion and release events', () => {
+    const completed = parseRawEvent(
+      {
+        id: { txDigest: '0xcomplete', eventSeq: '2' },
+        packageId,
+        transactionModule: 'task',
+        type: `${packageId}::task::TaskCompleted`,
+        sender: '0xprovider',
+        timestampMs: '3000',
+        parsedJson: {
+          task_id: '0xtask-id',
+          provider: '0xprovider',
+          result_blob_id: [114, 101, 115, 117, 108, 116],
+          payment_scheme: 1,
+          metered_units: 2,
+          verification_hash: Array.from(Buffer.from('aa'.repeat(32), 'hex')),
+          completed_at: 3000,
+        },
+        bcs: '',
+        bcsEncoding: 'base64',
+      },
+      packageId,
+    );
+    const released = parseRawEvent(
+      {
+        id: { txDigest: '0xrelease', eventSeq: '3' },
+        packageId,
+        transactionModule: 'task',
+        type: `${packageId}::task::TaskPaymentReleased`,
+        sender: '0xrequester',
+        timestampMs: '4000',
+        parsedJson: {
+          task_id: '0xtask-id',
+          requester: '0xrequester',
+          provider: '0xprovider',
+          refund_amount: '7',
+        },
+        bcs: '',
+        bcsEncoding: 'base64',
+      },
+      packageId,
+    );
+
+    expect(completed?.type).toBe('task.completed');
+    if (completed?.type !== 'task.completed') {
+      throw new Error('Unexpected event type');
+    }
+    expect(completed.paymentScheme).toBe(PaymentScheme.UPTO);
+    expect(completed.meteredUnits).toBe(2);
+    expect(completed.verificationHash).toBe('aa'.repeat(32));
+
+    expect(released?.type).toBe('task.released');
+    if (released?.type !== 'task.released') {
+      throw new Error('Unexpected event type');
+    }
+    expect(released.refundAmount).toBe(7n);
+  });
+
+  it('returns null for unknown event types', () => {
+    const event = parseRawEvent(
+      {
+        id: { txDigest: '0xunknown', eventSeq: '0' },
+        packageId,
+        transactionModule: 'misc',
+        type: `${packageId}::misc::Unknown`,
+        sender: '0xsender',
+        timestampMs: '0',
+        parsedJson: {},
+        bcs: '',
+        bcsEncoding: 'base64',
+      },
+      packageId,
+    );
+
+    expect(event).toBeNull();
+  });
+});
+
+describe('SqliteCursorStore', () => {
+  it('round-trips stored cursors', async () => {
+    const store = new SqliteCursorStore(await createDbPath());
+    const cursor = { txDigest: '0xtx', eventSeq: '7' };
+
+    await store.setCursor('event-type', cursor);
+    await expect(store.getCursor('event-type')).resolves.toEqual(cursor);
+    store.close();
+  });
+
+  it('returns null for unknown event types', async () => {
+    const store = new SqliteCursorStore(await createDbPath());
+    await expect(store.getCursor('missing')).resolves.toBeNull();
+    store.close();
+  });
+});

package/tests/evm/wallet.test.ts

@@ -0,0 +1,101 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { hexToBytes, recoverMessageAddress, verifyTypedData } from 'viem';
+
+import { EvmWallet } from '../../src/index.js';
+
+const PRIVATE_KEY = '0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80';
+const ADDRESS = '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266';
+const TOKEN_ADDRESS = '0x036CbD53842c5426634e7929541eC2318f3dCF7e';
+
+afterEach(() => {
+  vi.unstubAllGlobals();
+  vi.restoreAllMocks();
+});
+
+describe('EvmWallet', () => {
+  it('creates a wallet from a private key with the expected address', () => {
+    const wallet = new EvmWallet(hexToBytes(PRIVATE_KEY), { network: 'base' });
+
+    expect(wallet.address).toBe(ADDRESS);
+  });
+
+  it('signs messages with a recoverable signature', async () => {
+    const wallet = new EvmWallet(hexToBytes(PRIVATE_KEY), { network: 'base' });
+
+    const signature = await wallet.signMessage('hello x402');
+    const recovered = await recoverMessageAddress({ message: 'hello x402', signature: signature as `0x${string}` });
+
+    expect(recovered).toBe(ADDRESS);
+  });
+
+  it('signs typed data that verifies against the wallet address', async () => {
+    const wallet = new EvmWallet(hexToBytes(PRIVATE_KEY), { network: 'base-sepolia' });
+    const typedData = {
+      domain: {
+        name: 'AgenticMeshTest',
+        version: '1',
+        chainId: 84_532,
+        verifyingContract: '0x0000000000000000000000000000000000000001',
+      },
+      types: {
+        PaymentAuthorization: [
+          { name: 'paymentAddress', type: 'address' },
+          { name: 'amount', type: 'uint256' },
+          { name: 'nonce', type: 'string' },
+        ],
+      },
+      primaryType: 'PaymentAuthorization',
+      message: {
+        paymentAddress: '0x0000000000000000000000000000000000000002',
+        amount: 123n,
+        nonce: 'nonce-1',
+      },
+    } as const;
+
+    const signature = await wallet.signTypedData(typedData);
+    const verified = await verifyTypedData({
+      address: ADDRESS,
+      ...typedData,
+      signature: signature as `0x${string}`,
+    });
+
+    expect(verified).toBe(true);
+  });
+
+  it('queries balances through RPC calls', async () => {
+    const fetchMock = vi.fn(async (_input: RequestInfo | URL, init?: RequestInit) => {
+      const body = JSON.parse(String(init?.body)) as { id: number; method: string };
+      if (body.method === 'eth_getBalance') {
+        return new Response(JSON.stringify({ jsonrpc: '2.0', id: body.id, result: '0x5af3107a4000' }));
+      }
+
+      if (body.method === 'eth_call') {
+        return new Response(
+          JSON.stringify({
+            jsonrpc: '2.0',
+            id: body.id,
+            result: '0x00000000000000000000000000000000000000000000000000000000000004d2',
+          }),
+        );
+      }
+
+      throw new Error(`Unexpected RPC method: ${body.method}`);
+    });
+    vi.stubGlobal('fetch', fetchMock);
+
+    const wallet = new EvmWallet(hexToBytes(PRIVATE_KEY), {
+      network: 'base-sepolia',
+      rpcUrl: 'https://example.com/rpc',
+    });
+
+    await expect(wallet.getBalance()).resolves.toBe(100_000_000_000_000n);
+    await expect(wallet.getTokenBalance(TOKEN_ADDRESS)).resolves.toBe(1_234n);
+    expect(fetchMock).toHaveBeenCalledTimes(2);
+  });
+
+  it('uses the expected chain ids for supported networks', () => {
+    expect(new EvmWallet(hexToBytes(PRIVATE_KEY), { network: 'base' }).chain.id).toBe(8453);
+    expect(new EvmWallet(hexToBytes(PRIVATE_KEY), { network: 'base-sepolia' }).chain.id).toBe(84_532);
+    expect(new EvmWallet(hexToBytes(PRIVATE_KEY), { network: 'localhost' }).chain.id).toBe(31_337);
+  });
+});

package/tests/hybrid-store.test.ts

@@ -0,0 +1,121 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { mkdir, rm } from 'node:fs/promises';
+import { resolve } from 'node:path';
+
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+import { FilesystemBlobStore, HybridBlobStore, createWalrusBlobReference } from '../src/index.js';
+import type { WalrusBlobStore } from '../src/blobstore/walrus-store.js';
+
+const createdPaths: string[] = [];
+const encoder = new TextEncoder();
+
+async function createBaseDir(): Promise<string> {
+  const baseDir = resolve(process.cwd(), '.test-data', randomUUID());
+  createdPaths.push(baseDir);
+  await mkdir(baseDir, { recursive: true });
+  return baseDir;
+}
+
+afterEach(async () => {
+  await Promise.all(createdPaths.splice(0).map((path) => rm(path, { recursive: true, force: true })));
+});
+
+function sha256(data: Uint8Array): string {
+  return createHash('sha256').update(data).digest('hex');
+}
+
+describe('HybridBlobStore', () => {
+  it('uses Walrus when available', async () => {
+    const local = new FilesystemBlobStore(await createBaseDir());
+    const walrus = {
+      store: vi.fn().mockResolvedValue({
+        blobId: createWalrusBlobReference(Buffer.alloc(32, 0x22).toString('base64url'), 'a'.repeat(64)),
+        hash: 'a'.repeat(64),
+        checksum: 'a'.repeat(64),
+        contentHash: 'a'.repeat(64),
+        size: 4,
+        storedAt: Date.now(),
+      }),
+      fetch: vi.fn(),
+      exists: vi.fn(),
+      delete: vi.fn(),
+      getMetadata: vi.fn(),
+    } as unknown as WalrusBlobStore;
+    const store = new HybridBlobStore(walrus, local, { preferWalrus: true, cacheLocally: false });
+
+    const result = await store.store(encoder.encode('data'));
+
+    expect(walrus.store).toHaveBeenCalledTimes(1);
+    expect(result.blobId).toContain('walrus:');
+  });
+
+  it('falls back to the filesystem when Walrus is unavailable', async () => {
+    const local = new FilesystemBlobStore(await createBaseDir());
+    const walrus = {
+      store: vi.fn().mockRejectedValue(new Error('walrus down')),
+      fetch: vi.fn(),
+      exists: vi.fn(),
+      delete: vi.fn(),
+      getMetadata: vi.fn(),
+    } as unknown as WalrusBlobStore;
+    const store = new HybridBlobStore(walrus, local, { preferWalrus: true, cacheLocally: true });
+    const data = encoder.encode('fallback');
+
+    const result = await store.store(data);
+
+    expect(result.blobId).toMatch(/^[a-f0-9]{64}$/);
+    expect(await local.exists(result.blobId)).toBe(true);
+  });
+
+  it('caches Walrus blobs locally and serves fetches from the cache', async () => {
+    const local = new FilesystemBlobStore(await createBaseDir());
+    const data = encoder.encode('cached');
+    const contentHash = sha256(data);
+    const walrus = {
+      store: vi.fn().mockResolvedValue({
+        blobId: createWalrusBlobReference(Buffer.alloc(32, 0x33).toString('base64url'), contentHash),
+        hash: contentHash,
+        checksum: contentHash,
+        contentHash,
+        size: data.byteLength,
+        storedAt: Date.now(),
+      }),
+      fetch: vi.fn().mockResolvedValue(data),
+      exists: vi.fn(),
+      delete: vi.fn(),
+      getMetadata: vi.fn(),
+    } as unknown as WalrusBlobStore;
+    const store = new HybridBlobStore(walrus, local, { preferWalrus: true, cacheLocally: true });
+
+    const stored = await store.store(data);
+    const fetched = await store.fetch(stored.blobId);
+
+    expect(walrus.store).toHaveBeenCalledTimes(1);
+    expect(walrus.fetch).not.toHaveBeenCalled();
+    expect(Buffer.from(fetched ?? [])).toEqual(Buffer.from(data));
+  });
+
+  it('checks the local cache before querying Walrus', async () => {
+    const local = new FilesystemBlobStore(await createBaseDir());
+    const data = encoder.encode('remote then cached');
+    const contentHash = sha256(data);
+    const blobId = createWalrusBlobReference(Buffer.alloc(32, 0x44).toString('base64url'), contentHash);
+    const walrus = {
+      store: vi.fn(),
+      fetch: vi.fn().mockResolvedValue(data),
+      exists: vi.fn().mockResolvedValue(true),
+      delete: vi.fn(),
+      getMetadata: vi.fn(),
+    } as unknown as WalrusBlobStore;
+    const store = new HybridBlobStore(walrus, local, { preferWalrus: true, cacheLocally: true });
+
+    const firstFetch = await store.fetch(blobId);
+    const secondFetch = await store.fetch(blobId);
+
+    expect(Buffer.from(firstFetch ?? [])).toEqual(Buffer.from(data));
+    expect(Buffer.from(secondFetch ?? [])).toEqual(Buffer.from(data));
+    expect(walrus.fetch).toHaveBeenCalledTimes(1);
+    expect(await local.exists(contentHash)).toBe(true);
+  });
+});

package/tests/identity.test.ts

@@ -0,0 +1,161 @@
+import { randomUUID } from 'node:crypto';
+import { access, mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { join, resolve } from 'node:path';
+
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+const createdPaths: string[] = [];
+const encoder = new TextEncoder();
+
+interface KeytarMock {
+  getPassword: ReturnType<typeof vi.fn>;
+  setPassword: ReturnType<typeof vi.fn>;
+}
+
+afterEach(async () => {
+  vi.resetModules();
+  vi.doUnmock('keytar');
+  await Promise.all(
+    createdPaths.splice(0).map((path) => rm(path, { recursive: true, force: true })),
+  );
+});
+
+async function createDataDir(): Promise<string> {
+  const dataDir = resolve(process.cwd(), '.test-data', randomUUID());
+  createdPaths.push(dataDir);
+  await mkdir(dataDir, { recursive: true });
+  return dataDir;
+}
+
+async function fileExists(path: string): Promise<boolean> {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function createKeytarMock(): { keytar: KeytarMock; secrets: Map<string, string> } {
+  const secrets = new Map<string, string>();
+  const keytar = {
+    getPassword: vi.fn(async (service: string, account: string) => secrets.get(`${service}:${account}`) ?? null),
+    setPassword: vi.fn(async (service: string, account: string, password: string) => {
+      secrets.set(`${service}:${account}`, password);
+    }),
+  };
+
+  return { keytar, secrets };
+}
+
+function createUnavailableKeytarMock(): KeytarMock {
+  return {
+    getPassword: vi.fn(async () => {
+      throw new Error('keytar unavailable');
+    }),
+    setPassword: vi.fn(async () => {
+      throw new Error('keytar unavailable');
+    }),
+  };
+}
+
+async function loadKeypairModule(options?: { keytar?: KeytarMock }) {
+  vi.resetModules();
+  vi.doUnmock('keytar');
+
+  if (options?.keytar) {
+    vi.doMock('keytar', () => ({
+      default: options.keytar,
+      ...options.keytar,
+    }));
+  }
+
+  return await import('../src/identity/keypair.js');
+}
+
+describe('identity', () => {
+  it('generates a keypair with a 32-byte public key', async () => {
+    const { generateKeypair } = await loadKeypairModule();
+    const keypair = generateKeypair();
+
+    expect(keypair.publicKey).toHaveLength(32);
+    expect(keypair.secretKey).toHaveLength(32);
+  });
+
+  it('stores and loads identity keys from the OS keychain when available', async () => {
+    const dataDir = await createDataDir();
+    const keyPath = join(dataDir, 'identity.key');
+    const { keytar, secrets } = createKeytarMock();
+    const { loadOrCreateKeypair } = await loadKeypairModule({ keytar });
+
+    const first = await loadOrCreateKeypair(dataDir);
+    const second = await loadOrCreateKeypair(dataDir);
+
+    expect(Buffer.from(second.secretKey)).toEqual(Buffer.from(first.secretKey));
+    expect(Buffer.from(second.publicKey)).toEqual(Buffer.from(first.publicKey));
+    expect(await fileExists(keyPath)).toBe(false);
+    expect(secrets.get('hivemind-collective:identity-key')).toBe(Buffer.from(first.secretKey).toString('hex'));
+  });
+
+  it('migrates legacy file-based keys into the OS keychain', async () => {
+    const dataDir = await createDataDir();
+    const keyPath = join(dataDir, 'identity.key');
+    const { generateKeypair } = await loadKeypairModule();
+    const legacyKeypair = generateKeypair();
+    await writeFile(keyPath, Buffer.from(legacyKeypair.secretKey).toString('hex'));
+
+    const { keytar, secrets } = createKeytarMock();
+    const { loadOrCreateKeypair } = await loadKeypairModule({ keytar });
+    const loaded = await loadOrCreateKeypair(dataDir);
+
+    expect(Buffer.from(loaded.secretKey)).toEqual(Buffer.from(legacyKeypair.secretKey));
+    expect(await fileExists(keyPath)).toBe(false);
+    expect(secrets.get('hivemind-collective:identity-key')).toBe(Buffer.from(legacyKeypair.secretKey).toString('hex'));
+  });
+
+  it('falls back to file storage when keychain support is unavailable', async () => {
+    const dataDir = await createDataDir();
+    const keyPath = join(dataDir, 'identity.key');
+    const { loadOrCreateKeypair } = await loadKeypairModule({ keytar: createUnavailableKeytarMock() });
+
+    const first = await loadOrCreateKeypair(dataDir);
+    const second = await loadOrCreateKeypair(dataDir);
+
+    expect(Buffer.from(second.secretKey)).toEqual(Buffer.from(first.secretKey));
+    expect(await fileExists(keyPath)).toBe(true);
+    expect((await readFile(keyPath, 'utf8')).trim()).toBe(Buffer.from(first.secretKey).toString('hex'));
+  });
+
+  it('creates and parses DIDs', async () => {
+    const [{ createDID, parseDID }, { generateKeypair }] = await Promise.all([
+      import('../src/identity/did.js'),
+      loadKeypairModule(),
+    ]);
+    const keypair = generateKeypair();
+    const did = createDID(keypair.publicKey);
+    const parsed = parseDID(did);
+
+    expect(did).toMatch(/^did:mesh:/);
+    expect(Buffer.from(parsed.publicKey)).toEqual(Buffer.from(keypair.publicKey));
+  });
+
+  it('signs and verifies messages', async () => {
+    const [{ sign, verify }, { generateKeypair }] = await Promise.all([
+      import('../src/identity/signing.js'),
+      loadKeypairModule(),
+    ]);
+    const keypair = generateKeypair();
+    const message = encoder.encode('agentic mesh');
+    const signature = sign(message, keypair.secretKey);
+
+    expect(verify(message, signature, keypair.publicKey)).toBe(true);
+    expect(verify(encoder.encode('tampered'), signature, keypair.publicKey)).toBe(false);
+  });
+
+  it('rejects invalid DID formats', async () => {
+    const { isValidDID, parseDID } = await import('../src/identity/did.js');
+
+    expect(isValidDID('did:other:abc')).toBe(false);
+    expect(() => parseDID('did:mesh:')).toThrow();
+  });
+});