@hivemind-os/collective-core 0.2.0

package/tests/marketplace.test.ts

@@ -0,0 +1,308 @@
+import type { SuiEvent } from '@mysten/sui/client';
+import type { Ed25519Keypair } from '@mysten/sui/keypairs/ed25519';
+import { describe, expect, it, vi } from 'vitest';
+
+import { BidStatus, MarketplaceClient, TaskStatus, type MeshSuiClient } from '../src/index.js';
+
+const networkConfig = {
+  rpcUrl: 'http://127.0.0.1:9000',
+  faucetUrl: 'http://127.0.0.1:9123',
+  packageId: '0x1',
+  registryId: '0x2',
+};
+
+function getCommands(tx: { getData: () => { commands: Array<Record<string, unknown>> } }): Array<Record<string, unknown>> {
+  return tx.getData().commands;
+}
+
+function createBidPlacedEvent(payload: Record<string, unknown>): SuiEvent {
+  return {
+    id: { txDigest: '0xtx', eventSeq: '0' },
+    packageId: networkConfig.packageId,
+    transactionModule: 'marketplace',
+    type: `${networkConfig.packageId}::marketplace::BidPlaced`,
+    sender: '0xbidder',
+    timestampMs: '1000',
+    parsedJson: payload,
+    bcs: '',
+    bcsEncoding: 'base64',
+  } as unknown as SuiEvent;
+}
+
+function createTaskPostedEvent(payload: Record<string, unknown>): SuiEvent {
+  return {
+    id: { txDigest: '0xtask', eventSeq: '0' },
+    packageId: networkConfig.packageId,
+    transactionModule: 'task',
+    type: `${networkConfig.packageId}::task::TaskPosted`,
+    sender: '0xrequester',
+    timestampMs: '1000',
+    parsedJson: payload,
+    bcs: '',
+    bcsEncoding: 'base64',
+  } as unknown as SuiEvent;
+}
+
+describe('MarketplaceClient', () => {
+  it('places bids with explicit reputation scores', async () => {
+    const executeTransaction = vi.fn().mockResolvedValue({
+      digest: '0xtx',
+      objectChanges: [
+        {
+          type: 'created',
+          objectType: '0x1::marketplace::Bid',
+          objectId: '0xb01',
+        },
+      ],
+    });
+    const client = new MarketplaceClient(
+      {
+        executeTransaction,
+        getObject: vi.fn(),
+        queryEvents: vi.fn(),
+        client: { getOwnedObjects: vi.fn() },
+      } as unknown as MeshSuiClient,
+      networkConfig,
+    );
+
+    const result = await client.placeBid({
+      taskId: '0xa01',
+      bidPriceMist: 500n,
+      reputationScore: 88n,
+      evidenceBlob: 'proposal',
+      signer: {} as unknown as Ed25519Keypair,
+    });
+
+    const commands = getCommands(executeTransaction.mock.calls[0]?.[0]);
+    expect(commands[0]?.$kind).toBe('MoveCall');
+    expect(result).toEqual({ bidId: '0xb01', txDigest: '0xtx', reputationScore: 88n });
+  });
+
+  it('accepts bids and rejects competing active bids in the same transaction', async () => {
+    const executeTransaction = vi.fn().mockResolvedValue({ digest: '0xaccept' });
+    const queryEvents = vi.fn().mockResolvedValue({
+      events: [
+        createBidPlacedEvent({ bid_id: '0xb11', task_id: '0xa11' }),
+        createBidPlacedEvent({ bid_id: '0xb12', task_id: '0xa11' }),
+      ],
+      nextCursor: null,
+      hasMore: false,
+    });
+    const getObject = vi.fn(async (objectId: string) => {
+      if (objectId === '0xb11') {
+        return {
+          id: '0xb11',
+          task_id: '0xa11',
+          bidder: '0xprovider1',
+          bid_price: '600',
+          reputation_score: '40',
+          evidence_blob: 'first',
+          created_at: 1_000,
+          status: BidStatus.ACTIVE,
+        };
+      }
+      return {
+        id: '0xb12',
+        task_id: '0xa11',
+        bidder: '0xprovider2',
+        bid_price: '500',
+        reputation_score: '80',
+        evidence_blob: 'second',
+        created_at: 1_100,
+        status: BidStatus.ACTIVE,
+      };
+    });
+    const client = new MarketplaceClient(
+      {
+        executeTransaction,
+        getObject,
+        queryEvents,
+        client: { getOwnedObjects: vi.fn() },
+      } as unknown as MeshSuiClient,
+      networkConfig,
+    );
+
+    const result = await client.acceptBid({
+      taskId: '0xa11',
+      bidId: '0xb12',
+      signer: {} as unknown as Ed25519Keypair,
+    });
+
+    const commands = getCommands(executeTransaction.mock.calls[0]?.[0]);
+    expect(commands).toHaveLength(2);
+    expect(result).toEqual({ txDigest: '0xaccept', rejectedBidIds: ['0xb11'] });
+  });
+
+  it('accepts a bid without rejecting competitors when requested', async () => {
+    const executeTransaction = vi.fn().mockResolvedValue({ digest: '0xaccept' });
+    const client = new MarketplaceClient(
+      {
+        executeTransaction,
+        getObject: vi.fn(),
+        queryEvents: vi.fn(),
+        client: { getOwnedObjects: vi.fn() },
+      } as unknown as MeshSuiClient,
+      networkConfig,
+    );
+
+    const result = await client.acceptBid({
+      taskId: '0xa11',
+      bidId: '0xb12',
+      rejectCompeting: false,
+      signer: {} as unknown as Ed25519Keypair,
+    });
+
+    const commands = getCommands(executeTransaction.mock.calls[0]?.[0]);
+    expect(commands).toHaveLength(1);
+    expect(result).toEqual({ txDigest: '0xaccept', rejectedBidIds: [] });
+  });
+
+  it('parses bids for a task and ranks the recommended bid', async () => {
+    const queryEvents = vi.fn().mockResolvedValue({
+      events: [
+        createBidPlacedEvent({ bid_id: '0xb21', task_id: '0xa21' }),
+        createBidPlacedEvent({ bid_id: '0xb22', task_id: '0xa21' }),
+      ],
+      nextCursor: null,
+      hasMore: false,
+    });
+    const getObject = vi.fn(async (objectId: string) => {
+      if (objectId === '0xb21') {
+        return {
+          id: '0xb21',
+          task_id: '0xa21',
+          bidder: '0xprovider1',
+          bid_price: '700',
+          reputation_score: '100',
+          evidence_blob: 'strong reputation',
+          created_at: 1_000,
+          status: BidStatus.ACTIVE,
+        };
+      }
+      return {
+        id: '0xb22',
+        task_id: '0xa21',
+        bidder: '0xprovider2',
+        bid_price: '500',
+        reputation_score: '50',
+        evidence_blob: 'cheaper',
+        created_at: 1_100,
+        status: BidStatus.ACTIVE,
+      };
+    });
+    const client = new MarketplaceClient(
+      {
+        executeTransaction: vi.fn(),
+        getObject,
+        queryEvents,
+        client: { getOwnedObjects: vi.fn() },
+      } as unknown as MeshSuiClient,
+      networkConfig,
+    );
+
+    const bids = await client.getBidsForTask('0xa21');
+    const recommended = await client.getRecommendedBid('0xa21', { reputationWeight: 20n, priceWeight: 1n });
+
+    expect(bids).toHaveLength(2);
+    expect(bids[0]?.evidenceBlob).toBe('strong reputation');
+    expect(recommended?.bid.id).toBe('0xb21');
+    expect(recommended?.score).toBeGreaterThan(0n);
+  });
+
+  it('rejects invalid browse filters and negative recommendation weights', async () => {
+    const client = new MarketplaceClient(
+      {
+        executeTransaction: vi.fn(),
+        getObject: vi.fn(async () => ({
+          id: '0xb21',
+          task_id: '0xa21',
+          bidder: '0xprovider1',
+          bid_price: '700',
+          reputation_score: '100',
+          evidence_blob: 'strong reputation',
+          created_at: 1_000,
+          status: BidStatus.ACTIVE,
+        })),
+        queryEvents: vi.fn().mockResolvedValue({
+          events: [createBidPlacedEvent({ bid_id: '0xb21', task_id: '0xa21' })],
+          nextCursor: null,
+          hasMore: false,
+        }),
+        client: { getOwnedObjects: vi.fn() },
+      } as unknown as MeshSuiClient,
+      networkConfig,
+    );
+
+    await expect(client.browseOpenTasks({ limit: Number.NaN })).rejects.toThrow('filters.limit must be a positive safe integer.');
+    await expect(client.browseOpenTasks({ minPriceMist: 10n, maxPriceMist: 5n })).rejects.toThrow(
+      'filters.minPriceMist must be less than or equal to filters.maxPriceMist.',
+    );
+    await expect(client.getRecommendedBid('0xa21', { reputationWeight: -1n })).rejects.toThrow('options.reputationWeight must be non-negative.');
+  });
+
+  it('browses only open tasks that match category filters', async () => {
+    const queryEvents = vi.fn().mockResolvedValue({
+      events: [
+        createTaskPostedEvent({
+          task_id: '0xaa1',
+          requester: '0xrequester',
+          provider: '0x0',
+          capability: 'summarize',
+          category: 'analysis',
+          input_blob_id: 'blob-1',
+          agreement_hash: 'hash-1',
+          price: '500',
+          status: TaskStatus.OPEN,
+          dispute_window_ms: 60_000,
+          expires_at: Date.now() + 10_000,
+          created_at: 1_000,
+        }),
+        createTaskPostedEvent({
+          task_id: '0xaa2',
+          requester: '0xrequester',
+          provider: '0x0',
+          capability: 'code',
+          category: 'code',
+          input_blob_id: 'blob-2',
+          agreement_hash: 'hash-2',
+          price: '700',
+          status: TaskStatus.OPEN,
+          dispute_window_ms: 60_000,
+          expires_at: Date.now() + 10_000,
+          created_at: 2_000,
+        }),
+      ],
+      nextCursor: null,
+      hasMore: false,
+    });
+    const getObject = vi.fn(async (objectId: string) => ({
+      id: objectId,
+      requester: '0xrequester',
+      provider: '0x0',
+      capability: objectId === '0xaa1' ? 'summarize' : 'code',
+      category: objectId === '0xaa1' ? 'analysis' : 'code',
+      input_blob_id: objectId === '0xaa1' ? 'blob-1' : 'blob-2',
+      agreement_hash: objectId === '0xaa1' ? 'hash-1' : 'hash-2',
+      price: objectId === '0xaa1' ? '500' : '700',
+      status: objectId === '0xaa1' ? TaskStatus.OPEN : TaskStatus.ACCEPTED,
+      dispute_window_ms: 60_000,
+      created_at: objectId === '0xaa1' ? 1_000 : 2_000,
+      expires_at: Date.now() + 10_000,
+    }));
+    const client = new MarketplaceClient(
+      {
+        executeTransaction: vi.fn(),
+        getObject,
+        queryEvents,
+        client: { getOwnedObjects: vi.fn() },
+      } as unknown as MeshSuiClient,
+      networkConfig,
+    );
+
+    const tasks = await client.browseOpenTasks({ category: 'analysis', maxPriceMist: 600n });
+
+    expect(tasks).toHaveLength(1);
+    expect(tasks[0]?.id).toBe('0xaa1');
+    expect(tasks[0]?.category).toBe('analysis');
+  });
+});

package/tests/metering/hash-chain.test.ts

@@ -0,0 +1,32 @@
+import { describe, expect, it } from 'vitest';
+
+import { HashChain } from '../../src/metering/hash-chain.js';
+
+describe('HashChain', () => {
+  it('builds and verifies a hash chain', () => {
+    const seed = new TextEncoder().encode('seed');
+    const units = [
+      new TextEncoder().encode('one'),
+      new TextEncoder().encode('two'),
+    ];
+    const chain = new HashChain(seed);
+    for (const unit of units) {
+      chain.addUnit(unit);
+    }
+
+    const proof = chain.getProof();
+
+    expect(proof.unitCount).toBe(2);
+    expect(proof.intermediateHashes).toHaveLength(2);
+    expect(HashChain.verifyChain(proof, units, seed)).toBe(true);
+  });
+
+  it('detects tampering', () => {
+    const seed = new TextEncoder().encode('seed');
+    const chain = new HashChain(seed);
+    chain.addUnit(new TextEncoder().encode('one'));
+    const proof = chain.getProof();
+
+    expect(HashChain.verifyChain(proof, [new TextEncoder().encode('other')], seed)).toBe(false);
+  });
+});

package/tests/metering/meter.test.ts

@@ -0,0 +1,23 @@
+import { describe, expect, it } from 'vitest';
+
+import { UsageMeter } from '../../src/metering/meter.js';
+
+describe('UsageMeter', () => {
+  it('tracks usage and computes capped cost', () => {
+    const meter = new UsageMeter({ taskId: 'task-1', maxPrice: 500n, unitPrice: 300n });
+
+    meter.recordUnit(new TextEncoder().encode('a'));
+    meter.recordUnit(new TextEncoder().encode('b'));
+
+    expect(meter.getActualUnits()).toBe(2);
+    expect(meter.getCost()).toBe(500n);
+    expect(meter.getReport()).toEqual({
+      taskId: 'task-1',
+      actualUnits: 2,
+      actualCost: 500n,
+      maxPrice: 500n,
+      refundAmount: 0n,
+      verificationHash: meter.getVerificationHash(),
+    });
+  });
+});

package/tests/metering/streaming.test.ts

@@ -0,0 +1,52 @@
+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 { StreamingPaymentManager } from '../../src/metering/streaming.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, 'streaming.sqlite');
+}
+
+describe('StreamingPaymentManager', () => {
+  it('tracks a stream lifecycle and audit trail', async () => {
+    const paymentProcessor = vi.fn();
+    const manager = new StreamingPaymentManager({ dbPath: await createDbPath(), now: () => 1_700_000_000_000, paymentProcessor });
+
+    expect(manager.startStream('task-1', 1_000n, 400n)).toEqual({
+      taskId: 'task-1',
+      totalPaid: 0n,
+      maxBudget: 1_000n,
+      currentUnit: 0,
+      lastPaymentTimestamp: 1_700_000_000_000,
+    });
+    await expect(manager.payUnit('task-1')).resolves.toMatchObject({ totalPaid: 400n, currentUnit: 1 });
+    await expect(manager.payUnit('task-1')).resolves.toMatchObject({ totalPaid: 800n, currentUnit: 2 });
+    await expect(manager.payUnit('task-1')).resolves.toMatchObject({ totalPaid: 1_000n, currentUnit: 3 });
+
+    expect(paymentProcessor).toHaveBeenCalledTimes(3);
+    expect(manager.getAuditTrail('task-1')).toHaveLength(3);
+    expect(manager.finalizeStream('task-1')).toEqual({
+      state: {
+        taskId: 'task-1',
+        totalPaid: 1_000n,
+        maxBudget: 1_000n,
+        currentUnit: 3,
+        lastPaymentTimestamp: 1_700_000_000_000,
+      },
+      refundAmount: 0n,
+    });
+    manager.close();
+  });
+});

package/tests/metering/verification.test.ts

@@ -0,0 +1,27 @@
+import { describe, expect, it } from 'vitest';
+
+import { HashChain } from '../../src/metering/hash-chain.js';
+import { ResultVerifier, createMeteredResultEnvelope, decodeMeteredResult, getMeteredResultUnits, parseMeteredResultEnvelope, serializeMeteredResultEnvelope } from '../../src/metering/verification.js';
+
+describe('ResultVerifier', () => {
+  it('verifies metered result envelopes against task hashes', () => {
+    const seed = new TextEncoder().encode('agentic-mesh:metering:v1:task-1');
+    const chain = new HashChain(seed);
+    const units = [
+      new TextEncoder().encode('chunk-a'),
+      new TextEncoder().encode('chunk-b'),
+    ];
+    for (const unit of units) {
+      chain.addUnit(unit);
+    }
+
+    const proof = chain.getProof();
+    const envelope = createMeteredResultEnvelope(new Uint8Array(Buffer.concat(units.map((unit) => Buffer.from(unit)))), proof, 7);
+    const parsed = parseMeteredResultEnvelope(serializeMeteredResultEnvelope(envelope));
+    const verifier = new ResultVerifier();
+
+    expect(parsed).not.toBeNull();
+    expect(Buffer.from(decodeMeteredResult(parsed!)).toString('utf8')).toBe('chunk-achunk-b');
+    expect(verifier.verify({ id: 'task-1', verificationHash: proof.root }, parsed!.proof, getMeteredResultUnits(parsed!))).toBe(true);
+  });
+});

package/tests/payment/rail-selector.test.ts

@@ -0,0 +1,95 @@
+import { describe, expect, it } from 'vitest';
+
+import { PaymentRailSelector } from '../../src/index.js';
+
+const selector = new PaymentRailSelector();
+
+describe('PaymentRailSelector', () => {
+  it('always chooses Sui escrow for async tasks', () => {
+    expect(
+      selector.selectRail({
+        executionMode: 'async',
+        consumerHasSuiWallet: true,
+        consumerHasEvmWallet: true,
+        providerAcceptsSui: true,
+        providerAcceptsX402: true,
+        amount: 1n,
+        currency: 'USDC',
+      }),
+    ).toBe('sui-escrow');
+  });
+
+  it('prefers direct Sui settlement for sync tasks when both parties support it', () => {
+    expect(
+      selector.selectRail({
+        executionMode: 'sync',
+        consumerHasSuiWallet: true,
+        consumerHasEvmWallet: true,
+        providerAcceptsSui: true,
+        providerAcceptsX402: true,
+        amount: 1n,
+        currency: 'USDC',
+      }),
+    ).toBe('sui-transfer');
+  });
+
+  it('falls back to x402 when only EVM payment is available', () => {
+    expect(
+      selector.selectRail({
+        executionMode: 'sync',
+        consumerHasSuiWallet: false,
+        consumerHasEvmWallet: true,
+        providerAcceptsSui: false,
+        providerAcceptsX402: true,
+        amount: 1n,
+        currency: 'USDC',
+      }),
+    ).toBe('x402-base');
+  });
+
+  it('throws when no payment capability is available', () => {
+    expect(() =>
+      selector.selectRail({
+        executionMode: 'sync',
+        consumerHasSuiWallet: false,
+        consumerHasEvmWallet: false,
+        providerAcceptsSui: false,
+        providerAcceptsX402: false,
+        amount: 1n,
+        currency: 'USDC',
+      }),
+    ).toThrow('No compatible payment rail is available for this task.');
+  });
+
+  it('returns expected rails across wallet/provider combinations', () => {
+    const cases = [
+      { consumerHasSuiWallet: false, consumerHasEvmWallet: false, providerAcceptsSui: false, providerAcceptsX402: false, expected: [] },
+      { consumerHasSuiWallet: true, consumerHasEvmWallet: false, providerAcceptsSui: false, providerAcceptsX402: false, expected: [] },
+      { consumerHasSuiWallet: false, consumerHasEvmWallet: true, providerAcceptsSui: false, providerAcceptsX402: false, expected: [] },
+      { consumerHasSuiWallet: true, consumerHasEvmWallet: true, providerAcceptsSui: false, providerAcceptsX402: false, expected: [] },
+      { consumerHasSuiWallet: false, consumerHasEvmWallet: false, providerAcceptsSui: true, providerAcceptsX402: false, expected: [] },
+      { consumerHasSuiWallet: true, consumerHasEvmWallet: false, providerAcceptsSui: true, providerAcceptsX402: false, expected: ['sui-transfer'] },
+      { consumerHasSuiWallet: false, consumerHasEvmWallet: true, providerAcceptsSui: true, providerAcceptsX402: false, expected: [] },
+      { consumerHasSuiWallet: true, consumerHasEvmWallet: true, providerAcceptsSui: true, providerAcceptsX402: false, expected: ['sui-transfer'] },
+      { consumerHasSuiWallet: false, consumerHasEvmWallet: false, providerAcceptsSui: false, providerAcceptsX402: true, expected: [] },
+      { consumerHasSuiWallet: true, consumerHasEvmWallet: false, providerAcceptsSui: false, providerAcceptsX402: true, expected: [] },
+      { consumerHasSuiWallet: false, consumerHasEvmWallet: true, providerAcceptsSui: false, providerAcceptsX402: true, expected: ['x402-base'] },
+      { consumerHasSuiWallet: true, consumerHasEvmWallet: true, providerAcceptsSui: false, providerAcceptsX402: true, expected: ['x402-base'] },
+      { consumerHasSuiWallet: false, consumerHasEvmWallet: false, providerAcceptsSui: true, providerAcceptsX402: true, expected: [] },
+      { consumerHasSuiWallet: true, consumerHasEvmWallet: false, providerAcceptsSui: true, providerAcceptsX402: true, expected: ['sui-transfer'] },
+      { consumerHasSuiWallet: false, consumerHasEvmWallet: true, providerAcceptsSui: true, providerAcceptsX402: true, expected: ['x402-base'] },
+      { consumerHasSuiWallet: true, consumerHasEvmWallet: true, providerAcceptsSui: true, providerAcceptsX402: true, expected: ['sui-transfer', 'x402-base'] },
+    ] as const;
+
+    for (const testCase of cases) {
+      expect(
+        selector.getAvailableRails({
+          executionMode: 'sync',
+          amount: 1n,
+          currency: 'USDC',
+          ...testCase,
+        }),
+      ).toEqual(testCase.expected);
+    }
+  });
+});