@hivemind-os/collective-core 0.2.0

package/tests/blobstore.test.ts

@@ -0,0 +1,91 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { mkdir, rm, writeFile } from 'node:fs/promises';
+import { join, resolve } from 'node:path';
+
+import { afterEach, describe, expect, it } from 'vitest';
+
+import { BlobIntegrityError, FilesystemBlobStore } from '../src/index.js';
+
+const createdPaths: string[] = [];
+const encoder = new TextEncoder();
+
+afterEach(async () => {
+  await Promise.all(
+    createdPaths.splice(0).map((path) => rm(path, { recursive: true, force: true })),
+  );
+});
+
+async function createBaseDir(): Promise<string> {
+  const baseDir = resolve(process.cwd(), '.test-data', randomUUID());
+  createdPaths.push(baseDir);
+  await mkdir(baseDir, { recursive: true });
+  return baseDir;
+}
+
+describe('FilesystemBlobStore', () => {
+  it('stores blobs with SHA-256 metadata', async () => {
+    const store = new FilesystemBlobStore(await createBaseDir());
+    const data = encoder.encode('hello world');
+
+    const result = await store.store(data);
+    const checksum = createHash('sha256').update(data).digest('hex');
+
+    expect(result).toMatchObject({
+      blobId: checksum,
+      hash: checksum,
+      checksum,
+      contentHash: checksum,
+      size: data.byteLength,
+    });
+    expect(result.storedAt).toBeGreaterThan(0);
+  });
+
+  it('fetches stored blobs and returns metadata', async () => {
+    const baseDir = await createBaseDir();
+    const store = new FilesystemBlobStore(baseDir);
+    const data = encoder.encode('fetch me');
+    const { blobId } = await store.store(data);
+
+    const fetched = await store.fetch(blobId);
+    const metadata = await store.getMetadata(blobId);
+
+    expect(Buffer.from(fetched ?? [])).toEqual(Buffer.from(data));
+    expect(metadata).toMatchObject({
+      blobId,
+      contentHash: blobId,
+      size: data.byteLength,
+    });
+  });
+
+  it('returns null for missing blobs and after delete', async () => {
+    const store = new FilesystemBlobStore(await createBaseDir());
+    const data = encoder.encode('delete me');
+    const { blobId } = await store.store(data);
+
+    expect(await store.fetch('missing')).toBeNull();
+    await store.delete(blobId);
+    expect(await store.fetch(blobId)).toBeNull();
+  });
+
+  it('uses content-addressed ids for identical blobs', async () => {
+    const store = new FilesystemBlobStore(await createBaseDir());
+    const data = encoder.encode('same data');
+
+    const first = await store.store(data);
+    const second = await store.store(data);
+
+    expect(first.blobId).toBe(second.blobId);
+    expect(await store.exists(first.blobId)).toBe(true);
+  });
+
+  it('throws on content corruption', async () => {
+    const baseDir = await createBaseDir();
+    const store = new FilesystemBlobStore(baseDir);
+    const data = encoder.encode('keep me safe');
+    const { blobId } = await store.store(data);
+
+    await writeFile(join(baseDir, blobId), encoder.encode('tampered'));
+
+    await expect(store.fetch(blobId)).rejects.toBeInstanceOf(BlobIntegrityError);
+  });
+});

package/tests/cache.test.ts

@@ -0,0 +1,124 @@
+import { 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 { AgentCache, PaymentRail, type AgentCard } from '../src/index.js';
+
+const createdPaths: string[] = [];
+
+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, 'agents.sqlite');
+}
+
+function createAgent(overrides: Partial<AgentCard> = {}): AgentCard {
+  return {
+    id: '0xagent-1',
+    owner: '0xowner',
+    did: 'did:mesh:agent-1' as AgentCard['did'],
+    name: 'Summarizer',
+    description: 'Summarizes long documents',
+    capabilities: [
+      {
+        name: 'summarize',
+        description: 'Summarize text',
+        version: '1.0.0',
+        pricing: {
+          rail: PaymentRail.SUI_ESCROW,
+          amount: 100n,
+          currency: 'MIST',
+        },
+      },
+    ],
+    endpoint: 'https://example.com',
+    active: true,
+    version: 1,
+    registeredAt: 1_000,
+    updatedAt: 1_000,
+    ...overrides,
+  };
+}
+
+describe('AgentCache', () => {
+  it('upserts and reads agents', async () => {
+    const cache = new AgentCache(await createDbPath());
+    const agent = createAgent();
+
+    cache.upsertAgent(agent);
+
+    expect(cache.getAgent(agent.id)).toEqual(agent);
+    cache.close();
+  });
+
+  it('updates existing agents', async () => {
+    const cache = new AgentCache(await createDbPath());
+    cache.upsertAgent(createAgent());
+    cache.upsertAgent(createAgent({ name: 'Translator', version: 2, updatedAt: 2_000 }));
+
+    const updated = cache.getAgent('0xagent-1');
+    expect(updated?.name).toBe('Translator');
+    expect(updated?.version).toBe(2);
+    cache.close();
+  });
+
+  it('supports FTS capability searches', async () => {
+    const cache = new AgentCache(await createDbPath());
+    cache.upsertAgent(createAgent());
+
+    const matches = cache.searchByCapability('summarize');
+    expect(matches.map((entry) => entry.id)).toContain('0xagent-1');
+    cache.close();
+  });
+
+  it('removes agents', async () => {
+    const cache = new AgentCache(await createDbPath());
+    cache.upsertAgent(createAgent());
+    cache.removeAgent('0xagent-1');
+
+    expect(cache.getAgent('0xagent-1')).toBeNull();
+    cache.close();
+  });
+
+  it('finds agents by DID', async () => {
+    const cache = new AgentCache(await createDbPath());
+    cache.upsertAgent(createAgent());
+
+    expect(cache.getAgentByDID('did:mesh:agent-1')?.id).toBe('0xagent-1');
+    cache.close();
+  });
+
+  it('returns only active agents', async () => {
+    const cache = new AgentCache(await createDbPath());
+    cache.upsertAgent(createAgent());
+    cache.upsertAgent(
+      createAgent({ id: '0xagent-2', did: 'did:mesh:agent-2' as AgentCard['did'], active: false }),
+    );
+
+    expect(cache.getAllActive().map((entry) => entry.id)).toEqual(['0xagent-1']);
+    cache.close();
+  });
+
+  it('supports advanced queries locally and via delegate', async () => {
+    const delegated = [createAgent({ id: '0xdelegate', did: 'did:mesh:delegate' as AgentCard['did'] })];
+    const delegate = vi.fn().mockResolvedValue(delegated);
+    const delegatedCache = new AgentCache(await createDbPath(), { queryDelegate: delegate });
+    await expect(delegatedCache.queryAgentsAdvanced({ capability: 'summarize' })).resolves.toEqual(delegated);
+    delegatedCache.close();
+
+    const cache = new AgentCache(await createDbPath());
+    cache.upsertAgent(createAgent({ totalTasksCompleted: 4, totalTasksFailed: 1 }));
+    const results = await cache.queryAgentsAdvanced({ capability: 'summarize', minReputation: 0.7, sortBy: 'reputation' });
+    expect(results).toHaveLength(1);
+    cache.close();
+  });
+});

package/tests/crypto/encryption.test.ts

@@ -0,0 +1,70 @@
+import { describe, expect, it } from 'vitest';
+
+import {
+  decryptFromSender,
+  encryptForRecipient,
+  generateX25519KeyPair,
+  parseEncryptedPayload,
+  serializeEncryptedPayload,
+} from '../../src/index.js';
+
+function createLargePayload(): Uint8Array {
+  return Uint8Array.from({ length: 1024 * 1024 }, (_value, index) => index % 251);
+}
+
+describe('payload encryption', () => {
+  it('encrypts and decrypts payloads', async () => {
+    const sender = generateX25519KeyPair();
+    const recipient = generateX25519KeyPair();
+    const plaintext = new TextEncoder().encode('hello encrypted mesh');
+
+    const payload = await encryptForRecipient(plaintext, sender.privateKey, recipient.publicKey);
+    const decrypted = await decryptFromSender(payload, recipient.privateKey);
+
+    expect(Buffer.from(decrypted)).toEqual(Buffer.from(plaintext));
+  });
+
+  it('fails to decrypt with the wrong recipient key', async () => {
+    const sender = generateX25519KeyPair();
+    const recipient = generateX25519KeyPair();
+    const outsider = generateX25519KeyPair();
+    const payload = await encryptForRecipient(new TextEncoder().encode('secret'), sender.privateKey, recipient.publicKey);
+
+    await expect(decryptFromSender(payload, outsider.privateKey)).rejects.toBeInstanceOf(Error);
+  });
+
+  it('uses a fresh nonce for each encryption', async () => {
+    const sender = generateX25519KeyPair();
+    const recipient = generateX25519KeyPair();
+    const plaintext = new TextEncoder().encode('repeatable input');
+
+    const first = await encryptForRecipient(plaintext, sender.privateKey, recipient.publicKey);
+    const second = await encryptForRecipient(plaintext, sender.privateKey, recipient.publicKey);
+
+    expect(first.nonce).not.toBe(second.nonce);
+    expect(first.ciphertext).not.toBe(second.ciphertext);
+  });
+
+  it('handles large payloads', async () => {
+    const sender = generateX25519KeyPair();
+    const recipient = generateX25519KeyPair();
+    const plaintext = createLargePayload();
+
+    const payload = await encryptForRecipient(plaintext, sender.privateKey, recipient.publicKey);
+    const decrypted = await decryptFromSender(payload, recipient.privateKey);
+
+    expect(Buffer.from(decrypted)).toEqual(Buffer.from(plaintext));
+  }, 15_000);
+
+  it('serializes and parses encrypted payloads', async () => {
+    const sender = generateX25519KeyPair();
+    const recipient = generateX25519KeyPair();
+    const payload = await encryptForRecipient(new TextEncoder().encode('serialize me'), sender.privateKey, recipient.publicKey);
+
+    const serialized = serializeEncryptedPayload(payload);
+    const parsed = parseEncryptedPayload(serialized);
+
+    expect(parsed).toEqual(payload);
+    await expect(decryptFromSender(parsed as NonNullable<typeof parsed>, recipient.privateKey)).resolves.toBeInstanceOf(Uint8Array);
+  });
+});

package/tests/crypto/x25519.test.ts

@@ -0,0 +1,47 @@
+import { describe, expect, it } from 'vitest';
+
+import { computeSharedSecret, ed25519ToX25519, generateX25519KeyPair } from '../../src/index.js';
+
+function fixedSecret(start: number): Uint8Array {
+  return Uint8Array.from({ length: 32 }, (_value, index) => (start + index) % 256);
+}
+
+describe('x25519', () => {
+  it('generates 32-byte keypairs', () => {
+    const keyPair = generateX25519KeyPair();
+
+    expect(keyPair.privateKey).toHaveLength(32);
+    expect(keyPair.publicKey).toHaveLength(32);
+  });
+
+  it('converts Ed25519 keys deterministically', () => {
+    const secretKey = fixedSecret(1);
+
+    const first = ed25519ToX25519(secretKey);
+    const second = ed25519ToX25519(secretKey);
+
+    expect(Buffer.from(first.privateKey)).toEqual(Buffer.from(second.privateKey));
+    expect(Buffer.from(first.publicKey)).toEqual(Buffer.from(second.publicKey));
+  });
+
+  it('derives the same shared secret for both peers', () => {
+    const alice = generateX25519KeyPair();
+    const bob = generateX25519KeyPair();
+
+    const aliceShared = computeSharedSecret(alice.privateKey, bob.publicKey);
+    const bobShared = computeSharedSecret(bob.privateKey, alice.publicKey);
+
+    expect(Buffer.from(aliceShared)).toEqual(Buffer.from(bobShared));
+  });
+
+  it('produces different shared secrets for different peers', () => {
+    const alice = generateX25519KeyPair();
+    const bob = generateX25519KeyPair();
+    const carol = generateX25519KeyPair();
+
+    const sharedWithBob = computeSharedSecret(alice.privateKey, bob.publicKey);
+    const sharedWithCarol = computeSharedSecret(alice.privateKey, carol.publicKey);
+
+    expect(Buffer.from(sharedWithBob)).not.toEqual(Buffer.from(sharedWithCarol));
+  });
+});

package/tests/dispute/client.test.ts

@@ -0,0 +1,238 @@
+import type { Ed25519Keypair } from '@mysten/sui/keypairs/ed25519';
+import { describe, expect, it, vi } from 'vitest';
+
+import { DisputeClient, DisputeStatus, type MeshSuiClient } from '../../src/index.js';
+
+const contractConfig = { packageId: '0x1' };
+
+function getMoveTargets(tx: { getData: () => { commands: Array<Record<string, unknown>> } }): string[] {
+  return tx
+    .getData()
+    .commands.map((command) => {
+      if ('MoveCall' in command && typeof command.MoveCall === 'object' && command.MoveCall) {
+        const moveCall = command.MoveCall as {
+          package: string;
+          module: string;
+          function: string;
+        };
+        return `${moveCall.package}::${moveCall.module}::${moveCall.function}`;
+      }
+      return '';
+    })
+    .filter(Boolean);
+}
+
+describe('DisputeClient', () => {
+  it('opens disputes and returns the created dispute id', async () => {
+    const executeTransaction = vi.fn().mockResolvedValue({
+      digest: '0xtx',
+      objectChanges: [
+        {
+          type: 'created',
+          objectType: '0x1::dispute::Dispute',
+          objectId: '0xdispute',
+        },
+      ],
+      events: [],
+    });
+    const client = new DisputeClient(
+      {
+        executeTransaction,
+        getObject: vi.fn(),
+        queryEvents: vi.fn(),
+      } as unknown as MeshSuiClient,
+      contractConfig,
+    );
+
+    const result = await client.openDispute({
+      taskId: '0x3',
+      evidenceBlobId: 'walrus:evidence',
+      proposedSplitMist: 500n,
+      arbitratorAddress: '0x2',
+      signer: {} as Ed25519Keypair,
+    });
+
+    const tx = executeTransaction.mock.calls[0]?.[0];
+    expect(getMoveTargets(tx).some((target) => target.endsWith('::dispute::open_dispute'))).toBe(true);
+    expect(result).toEqual({ disputeId: '0xdispute', txDigest: '0xtx' });
+  });
+
+  it('supports respond, accept, and arbitrate flows', async () => {
+    const executeTransaction = vi
+      .fn()
+      .mockResolvedValueOnce({ digest: '0xrespond', events: [], objectChanges: [] })
+      .mockResolvedValueOnce({
+        digest: '0xaccept',
+        events: [
+          {
+            type: '0x1::dispute::DisputeMutuallyResolved',
+            parsedJson: { requester_amount: '250', provider_amount: '750' },
+          },
+        ],
+        objectChanges: [],
+      })
+      .mockResolvedValueOnce({ digest: '0xarb', events: [], objectChanges: [] });
+    const client = new DisputeClient(
+      {
+        executeTransaction,
+        getObject: vi.fn(),
+        queryEvents: vi.fn(),
+      } as unknown as MeshSuiClient,
+      contractConfig,
+    );
+
+    await expect(client.respondToDispute({
+      disputeId: '0x4',
+      evidenceBlobId: 'walrus:reply',
+      proposedSplitMist: 250n,
+      signer: {} as Ed25519Keypair,
+    })).resolves.toEqual({ txDigest: '0xrespond' });
+
+    await expect(client.acceptResolution({
+      disputeId: '0x4',
+      taskId: '0x3',
+      signer: {} as Ed25519Keypair,
+    })).resolves.toEqual({ requesterAmount: 250n, providerAmount: 750n, txDigest: '0xaccept' });
+
+    await expect(client.arbitrate({
+      disputeId: '0x4',
+      taskId: '0x3',
+      rulingSplitMist: 400n,
+      signer: {} as Ed25519Keypair,
+    })).resolves.toEqual({ txDigest: '0xarb' });
+  });
+
+  it('parses dispute objects', async () => {
+    const client = new DisputeClient(
+      {
+        executeTransaction: vi.fn(),
+        getObject: vi.fn().mockResolvedValue({
+          objectId: '0xdispute',
+          task_id: '0xtask',
+          requester: '0xrequester',
+          provider: '0xprovider',
+          escrow_amount: '1000',
+          status: 1,
+          requester_evidence_blob: 'walrus:req',
+          provider_evidence_blob: 'walrus:prov',
+          requester_proposed_split: '600',
+          provider_proposed_split: '400',
+          arbitrator: '0x0',
+          ruling_split: '0',
+          opened_at: 100,
+          responded_at: 200,
+          resolved_at: 0,
+          resolution_deadline: 300,
+        }),
+        queryEvents: vi.fn(),
+      } as unknown as MeshSuiClient,
+      contractConfig,
+    );
+
+    const dispute = await client.getDispute('0xdispute');
+
+    expect(dispute).toEqual({
+      id: '0xdispute',
+      taskId: '0xtask',
+      requester: '0xrequester',
+      provider: '0xprovider',
+      escrowAmount: 1000n,
+      status: DisputeStatus.RESPONDED,
+      requesterEvidenceBlob: 'walrus:req',
+      providerEvidenceBlob: 'walrus:prov',
+      requesterProposedSplit: 600n,
+      providerProposedSplit: 400n,
+      arbitrator: undefined,
+      rulingSplit: 0n,
+      openedAt: 100,
+      respondedAt: 200,
+      resolvedAt: undefined,
+      resolutionDeadline: 300,
+    });
+  });
+
+  it('finds disputes by task id', async () => {
+    const getObject = vi.fn().mockResolvedValue({
+      objectId: '0xdispute',
+      task_id: '0xtask',
+      requester: '0xrequester',
+      provider: '0xprovider',
+      escrow_amount: '1000',
+      status: 0,
+      requester_evidence_blob: 'walrus:req',
+      provider_evidence_blob: '',
+      requester_proposed_split: '500',
+      provider_proposed_split: '0',
+      arbitrator: '0x3',
+      ruling_split: '0',
+      opened_at: 100,
+      responded_at: 0,
+      resolved_at: 0,
+      resolution_deadline: 300,
+    });
+    const client = new DisputeClient(
+      {
+        executeTransaction: vi.fn(),
+        getObject,
+        queryEvents: vi.fn().mockResolvedValue({
+          events: [
+            {
+              type: '0x1::dispute::DisputeOpened',
+              parsedJson: { dispute_id: '0xdispute', task_id: '0xtask' },
+            },
+          ],
+          nextCursor: null,
+          hasMore: false,
+        }),
+      } as unknown as MeshSuiClient,
+      contractConfig,
+    );
+
+    const dispute = await client.getDisputeByTask('0xtask');
+
+    expect(getObject).toHaveBeenCalledWith('0xdispute');
+    expect(dispute?.id).toBe('0xdispute');
+    expect(dispute?.arbitrator).toBe('0x3');
+  });
+
+  it('fails when the mutual resolution event is missing payout fields', async () => {
+    const client = new DisputeClient(
+      {
+        executeTransaction: vi.fn().mockResolvedValue({
+          digest: '0xaccept',
+          events: [{ type: '0x1::dispute::DisputeMutuallyResolved', parsedJson: {} }],
+          objectChanges: [],
+        }),
+        getObject: vi.fn(),
+        queryEvents: vi.fn(),
+      } as unknown as MeshSuiClient,
+      contractConfig,
+    );
+
+    await expect(client.acceptResolution({
+      disputeId: '0x4',
+      taskId: '0x3',
+      signer: {} as Ed25519Keypair,
+    })).rejects.toThrow('DisputeMutuallyResolved event did not include requester_amount.');
+  });
+
+  it('rejects invalid dispute ids before submitting dispute mutations', async () => {
+    const executeTransaction = vi.fn();
+    const client = new DisputeClient(
+      {
+        executeTransaction,
+        getObject: vi.fn(),
+        queryEvents: vi.fn(),
+      } as unknown as MeshSuiClient,
+      contractConfig,
+    );
+
+    await expect(client.respondToDispute({
+      disputeId: 'not-an-object-id',
+      evidenceBlobId: 'walrus:reply',
+      proposedSplitMist: 1n,
+      signer: {} as Ed25519Keypair,
+    })).rejects.toThrow('disputeId must be a 0x-prefixed hex object id.');
+    expect(executeTransaction).not.toHaveBeenCalled();
+  });
+});