@hivemind-os/collective-core 0.2.0

package/tests/registry.test.ts

@@ -0,0 +1,183 @@
+import type { Ed25519Keypair } from '@mysten/sui/keypairs/ed25519';
+import { describe, expect, it, vi } from 'vitest';
+
+import { PaymentRail, RegistryClient, 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 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('RegistryClient', () => {
+  it('builds a register agent transaction', async () => {
+    const executeTransaction = vi.fn().mockResolvedValue({
+      digest: '0xtx',
+      objectChanges: [
+        {
+          type: 'created',
+          objectType: '0x1::registry::AgentCard',
+          objectId: '0x3',
+        },
+      ],
+    });
+    const client = new RegistryClient(
+      {
+        executeTransaction,
+        queryEvents: vi.fn(),
+        getObject: vi.fn(),
+      } as unknown as MeshSuiClient,
+      networkConfig,
+    );
+
+    const result = await client.registerAgent({
+      name: 'Agent One',
+      did: 'did:mesh:agent-1',
+      description: 'Helpful',
+      capabilities: [
+        {
+          name: 'summarize',
+          description: 'Summarize text',
+          version: '1.0.0',
+          pricing: {
+            rail: PaymentRail.SUI_ESCROW,
+            amount: 100n,
+            currency: 'MIST',
+          },
+        },
+      ],
+      endpoint: 'https://example.com',
+      keypair: {} as unknown as Ed25519Keypair,
+    });
+
+    const tx = executeTransaction.mock.calls[0]?.[0];
+    expect(getMoveTargets(tx).some((target) => target.endsWith('::registry::register_agent'))).toBe(true);
+    expect(result).toEqual({ txDigest: '0xtx', agentCardId: '0x3' });
+  });
+
+  it('sets an encryption key after registration when provided', async () => {
+    const executeTransaction = vi
+      .fn()
+      .mockResolvedValueOnce({
+        digest: '0xtx',
+        objectChanges: [
+          {
+            type: 'created',
+            objectType: '0x1::registry::AgentCard',
+            objectId: '0x3',
+          },
+        ],
+      })
+      .mockResolvedValueOnce({ digest: '0xtx2', objectChanges: [] });
+    const client = new RegistryClient(
+      {
+        executeTransaction,
+        queryEvents: vi.fn(),
+        getObject: vi.fn(),
+      } as unknown as MeshSuiClient,
+      networkConfig,
+    );
+    const encryptionPublicKey = Uint8Array.from({ length: 32 }, (_value, index) => index);
+
+    const result = await client.registerAgent({
+      name: 'Agent One',
+      did: 'did:mesh:agent-1',
+      description: 'Helpful',
+      capabilities: [],
+      endpoint: 'https://example.com',
+      encryptionPublicKey,
+      keypair: {} as unknown as Ed25519Keypair,
+    });
+
+    expect(executeTransaction).toHaveBeenCalledTimes(2);
+    expect(getMoveTargets(executeTransaction.mock.calls[1]?.[0]).some((target) => target.endsWith('::registry::set_encryption_key'))).toBe(true);
+    expect(result).toEqual({ txDigest: '0xtx', agentCardId: '0x3' });
+  });
+
+  it('parses encryption public keys from agent cards', async () => {
+    const client = new RegistryClient(
+      {
+        executeTransaction: vi.fn(),
+        queryEvents: vi.fn(),
+        getObject: vi.fn().mockResolvedValue({
+          id: '0xcard',
+          owner: '0xowner',
+          did: 'did:mesh:agent-1',
+          name: 'Agent One',
+          description: 'Helpful',
+          capabilities: [],
+          endpoint: 'https://example.com',
+          encryption_public_key: Array.from({ length: 32 }, (_value, index) => index),
+          active: true,
+          version: 1,
+          registered_at: 1,
+          updated_at: 2,
+        }),
+      } as unknown as MeshSuiClient,
+      networkConfig,
+    );
+
+    const card = await client.getAgentCard('0xcard');
+
+    expect(card?.encryptionPublicKey).toBe('000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f');
+  });
+
+  it('queries AgentRegistered events for capability discovery', async () => {
+    const queryEvents = vi.fn().mockResolvedValue({ events: [], nextCursor: null, hasMore: false });
+    const client = new RegistryClient(
+      {
+        executeTransaction: vi.fn(),
+        queryEvents,
+        getObject: vi.fn(),
+      } as unknown as MeshSuiClient,
+      networkConfig,
+    );
+
+    await client.discoverByCapability('summarize', 5);
+
+    expect(queryEvents).toHaveBeenCalledWith('0x1::registry::AgentRegistered', null, 20);
+  });
+
+  it('rejects invalid DIDs before submitting a transaction', async () => {
+    const executeTransaction = vi.fn();
+    const client = new RegistryClient(
+      {
+        executeTransaction,
+        queryEvents: vi.fn(),
+        getObject: vi.fn(),
+      } as unknown as MeshSuiClient,
+      networkConfig,
+    );
+
+    await expect(
+      client.registerAgent({
+        name: 'Agent One',
+        did: 'invalid-did',
+        description: 'Helpful',
+        capabilities: [],
+        endpoint: 'https://example.com',
+        keypair: {} as unknown as Ed25519Keypair,
+      }),
+    ).rejects.toThrow('did must be a did:mesh identifier.');
+    expect(executeTransaction).not.toHaveBeenCalled();
+  });
+});

package/tests/relay-consumer-client.test.ts

@@ -0,0 +1,119 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+import { PaymentRail } from '@hivemind-os/collective-types';
+
+import type { AuthProvider, X402Client } from '../src/index.js';
+import { RelayConsumerClient } from '../src/relay/consumer-client.js';
+
+const originalFetch = globalThis.fetch;
+const identity = {
+  getDID: () => 'did:mesh:consumer',
+  toSuiSigner: () => ({
+    sign: vi.fn(async () => new Uint8Array([1, 2, 3])),
+  }),
+} as unknown as AuthProvider;
+
+afterEach(() => {
+  globalThis.fetch = originalFetch;
+  vi.restoreAllMocks();
+});
+
+describe('RelayConsumerClient', () => {
+  it('returns direct sync responses without payment negotiation', async () => {
+    const fetchMock = vi.fn(async () =>
+      new Response(JSON.stringify({ ok: true }), {
+        status: 200,
+        headers: {
+          'content-type': 'application/json',
+          'x-mesh-response-id': 'task-1',
+          'x-mesh-provider': 'did:mesh:provider',
+        },
+      }),
+    );
+    globalThis.fetch = fetchMock as typeof fetch;
+
+    const client = new RelayConsumerClient(null, identity, { relayUrl: 'https://relay.example' });
+    const result = await client.executeSync({
+      providerDid: 'did:mesh:provider',
+      capability: 'echo',
+      input: { message: 'hello' },
+      paymentRail: PaymentRail.SUI_TRANSFER,
+    });
+
+    expect(result.result).toEqual({ ok: true });
+    expect(result.taskId).toBe('task-1');
+    expect(result.providerDid).toBe('did:mesh:provider');
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+    expect(fetchMock.mock.calls[0]?.[1]?.headers).toMatchObject({
+      'x-mesh-target-provider': 'did:mesh:provider',
+      'x-mesh-payment-rail': PaymentRail.SUI_TRANSFER,
+      'x-mesh-sequence': '1',
+    });
+  });
+
+  it('retries x402 challenges with a payment header', async () => {
+    const x402Client = {
+      parse402Response: vi.fn(() => ({ challenge: true })),
+      createPaymentHeader: vi.fn(() => 'signed-x402'),
+    } as unknown as X402Client;
+
+    const fetchMock = vi
+      .fn()
+      .mockResolvedValueOnce(
+        new Response(
+          JSON.stringify({
+            payment: {
+              rail: PaymentRail.X402_BASE,
+              paymentAddress: '0x0000000000000000000000000000000000000abc',
+              amount: '25',
+              currency: 'USDC',
+              network: 'base-sepolia',
+              relayFee: '5',
+              expiresAt: Date.now() + 60_000,
+              nonce: 'nonce-1',
+              extra: { 'payment-required': 'encoded-402' },
+            },
+          }),
+          {
+            status: 402,
+            headers: { 'content-type': 'application/json' },
+          },
+        ),
+      )
+      .mockResolvedValueOnce(
+        new Response(JSON.stringify({ ok: true }), {
+          status: 200,
+          headers: {
+            'content-type': 'application/json',
+            'payment-response': 'receipt-1',
+            'x-mesh-response-id': 'task-2',
+          },
+        }),
+      );
+    globalThis.fetch = fetchMock as typeof fetch;
+
+    const client = new RelayConsumerClient(x402Client, identity, { relayUrl: 'https://relay.example' });
+    const result = await client.executeSync({
+      providerDid: 'did:mesh:provider',
+      capability: 'echo',
+      input: { message: 'paid' },
+      paymentRail: PaymentRail.X402_BASE,
+    });
+
+    expect(x402Client.parse402Response).toHaveBeenCalledWith(
+      { 'payment-required': 'encoded-402' },
+      expect.objectContaining({
+        payment: expect.objectContaining({ nonce: 'nonce-1', amount: '25' }),
+      }),
+    );
+    expect(x402Client.createPaymentHeader).toHaveBeenCalledWith({ challenge: true });
+    expect(fetchMock).toHaveBeenCalledTimes(2);
+    expect(fetchMock.mock.calls[1]?.[1]?.headers).toMatchObject({
+      'payment-signature': 'signed-x402',
+      'x-mesh-payment-nonce': 'nonce-1',
+      'x-mesh-sequence': '2',
+    });
+    expect(result.paymentReceipt).toBe('receipt-1');
+    expect(result.taskId).toBe('task-2');
+  });
+});

package/tests/relay-registry/client.test.ts

@@ -0,0 +1,261 @@
+import type { Ed25519Keypair } from '@mysten/sui/keypairs/ed25519';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+import { RelayDiscovery, RelayNodeStatus, RelayRegistryClient, StakingClient, type MeshSuiClient, type RelayNode } 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);
+}
+
+function createRelay(overrides: Partial<RelayNode> = {}): RelayNode {
+  return {
+    id: '0x111',
+    operator: '0xaaa',
+    endpoint: 'wss://relay-1.mesh.example/ws',
+    stakePositionId: '0x123',
+    capabilities: ['routing', 'streaming'],
+    region: 'us-east',
+    status: RelayNodeStatus.ACTIVE,
+    registeredAt: 1_000,
+    lastHeartbeat: 1_500,
+    routingFeeBps: 50,
+    totalRouted: 10,
+    totalFeesEarnedMist: 999n,
+    stakeAmountMist: 100_000_000_000n,
+    heartbeatAgeMs: 500,
+    isHeartbeatFresh: true,
+    ...overrides,
+  };
+}
+
+afterEach(() => {
+  vi.restoreAllMocks();
+  vi.useRealTimers();
+});
+
+describe('RelayRegistryClient', () => {
+  it('builds relay registry transactions', async () => {
+    const executeTransaction = vi
+      .fn()
+      .mockResolvedValueOnce({
+        digest: '0xregister',
+        objectChanges: [{ type: 'created', objectType: '0x1::relay_registry::RelayNode', objectId: '0x111' }],
+        events: [{ type: '0x1::relay_registry::RelayRegistered', parsedJson: { relay_id: '0x111' } }],
+      })
+      .mockResolvedValueOnce({
+        digest: '0xheartbeat',
+        objectChanges: [],
+        events: [{ type: '0x1::relay_registry::RelayHeartbeat', parsedJson: { last_heartbeat: 1234 } }],
+      })
+      .mockResolvedValueOnce({ digest: '0xdeactivate', objectChanges: [], events: [] });
+    const client = new RelayRegistryClient(
+      {
+        executeTransaction,
+        queryEvents: vi.fn(),
+        getObject: vi.fn(),
+      } as unknown as MeshSuiClient,
+      contractConfig,
+    );
+
+    await expect(
+      client.registerRelay({
+        endpoint: 'wss://relay.mesh.example/ws',
+        stakeId: '0x123',
+        capabilities: ['routing'],
+        region: 'us-east',
+        routingFeeBps: 50,
+        signer: {} as Ed25519Keypair,
+      }),
+    ).resolves.toEqual({ relayId: '0x111', txDigest: '0xregister' });
+    await expect(client.heartbeat({ relayId: '0x111', signer: {} as Ed25519Keypair })).resolves.toEqual({
+      lastHeartbeat: 1234,
+      txDigest: '0xheartbeat',
+    });
+    await expect(client.deactivateRelay({ relayId: '0x111', signer: {} as Ed25519Keypair })).resolves.toEqual({
+      txDigest: '0xdeactivate',
+    });
+
+    expect(getMoveTargets(executeTransaction.mock.calls[0]?.[0]).some((target) => target.endsWith('::relay_registry::register_relay'))).toBe(true);
+    expect(getMoveTargets(executeTransaction.mock.calls[1]?.[0]).some((target) => target.endsWith('::relay_registry::heartbeat'))).toBe(true);
+    expect(getMoveTargets(executeTransaction.mock.calls[2]?.[0]).some((target) => target.endsWith('::relay_registry::deactivate_relay'))).toBe(true);
+  });
+
+  it('rejects external routing metric reports', async () => {
+    const executeTransaction = vi.fn();
+    const client = new RelayRegistryClient(
+      {
+        executeTransaction,
+        queryEvents: vi.fn(),
+        getObject: vi.fn(),
+      } as unknown as MeshSuiClient,
+      contractConfig,
+    );
+
+    await expect(
+      client.recordRouting({ relayId: '0x111', feeAmountMist: 25n, signer: {} as Ed25519Keypair }),
+    ).rejects.toThrow('Relay routing metrics are package-internal and cannot be reported by external operators.');
+    expect(executeTransaction).not.toHaveBeenCalled();
+  });
+
+  it('parses relay nodes and enriches stake metadata', async () => {
+    vi.useFakeTimers();
+    vi.setSystemTime(2_000);
+    vi.spyOn(StakingClient.prototype, 'getStakePosition').mockResolvedValue({
+      id: '0x123',
+      owner: '0xaaa',
+      stakeType: 'relay',
+      balanceMist: 200_000_000_000n,
+      stakedAt: 1,
+      deactivatedAt: 0,
+      slashedAmount: 0n,
+      isActive: true,
+      meetsMinium: true,
+      meetsMinimum: true,
+    });
+    const client = new RelayRegistryClient(
+      {
+        executeTransaction: vi.fn(),
+        queryEvents: vi.fn(),
+        getObject: vi.fn().mockResolvedValue({
+          objectId: '0x111',
+          operator: '0xaaa',
+          endpoint: 'wss://relay.mesh.example/ws',
+          stake_position_id: '0x123',
+          capabilities: ['routing', 'streaming'],
+          region: 'us-east',
+          status: 0,
+          registered_at: 1_000,
+          last_heartbeat: 1_500,
+          routing_fee_bps: 50,
+          total_routed: 7,
+          total_fees_earned: '999',
+        }),
+      } as unknown as MeshSuiClient,
+      contractConfig,
+    );
+
+    await expect(client.getRelay('0x111')).resolves.toEqual({
+      id: '0x111',
+      operator: '0xaaa',
+      endpoint: 'wss://relay.mesh.example/ws',
+      stakePositionId: '0x123',
+      capabilities: ['routing', 'streaming'],
+      region: 'us-east',
+      status: RelayNodeStatus.ACTIVE,
+      registeredAt: 1_000,
+      lastHeartbeat: 1_500,
+      routingFeeBps: 50,
+      totalRouted: 7,
+      totalFeesEarnedMist: 999n,
+      stakeAmountMist: 200_000_000_000n,
+      heartbeatAgeMs: 500,
+      isHeartbeatFresh: true,
+    });
+  });
+
+  it('lists relays with active filtering by default', async () => {
+    vi.useFakeTimers();
+    vi.setSystemTime(10_000);
+    vi.spyOn(StakingClient.prototype, 'getStakePosition').mockImplementation(async (stakeId: string) => ({
+      id: stakeId,
+      owner: '0xaaa',
+      stakeType: 'relay',
+      balanceMist: stakeId === '0x124' ? 150_000_000_000n : 100_000_000_000n,
+      stakedAt: 1,
+      deactivatedAt: 0,
+      slashedAmount: 0n,
+      isActive: true,
+      meetsMinium: true,
+      meetsMinimum: true,
+    }));
+    const client = new RelayRegistryClient(
+      {
+        executeTransaction: vi.fn(),
+        queryEvents: vi.fn().mockResolvedValue({
+          events: [
+            { type: '0x1::relay_registry::RelayRegistered', parsedJson: { relay_id: '0x111' } },
+            { type: '0x1::relay_registry::RelayRegistered', parsedJson: { relay_id: '0x112' } },
+          ],
+          nextCursor: null,
+          hasMore: false,
+        }),
+        getObject: vi.fn().mockImplementation(async (relayId: string) => ({
+          objectId: relayId,
+          operator: relayId === '0x112' ? '0xaab' : '0xaaa',
+          endpoint: `wss://${relayId}.mesh.example/ws`,
+          stake_position_id: relayId === '0x112' ? '0x124' : '0x123',
+          capabilities: relayId === '0x112' ? ['routing', 'streaming'] : ['routing'],
+          region: relayId === '0x112' ? 'us-west' : 'us-east',
+          status: relayId === '0x112' ? 1 : 0,
+          registered_at: 1_000,
+          last_heartbeat: relayId === '0x112' ? 9_000 : 9_500,
+          routing_fee_bps: relayId === '0x112' ? 25 : 50,
+          total_routed: 0,
+          total_fees_earned: '0',
+        })),
+      } as unknown as MeshSuiClient,
+      contractConfig,
+    );
+
+    const activeRelays = await client.listRelays();
+    const westRelays = await client.listRelays({ activeOnly: false, region: 'us-west' });
+
+    expect(activeRelays.map((relay) => relay.id)).toEqual(['0x111']);
+    expect(westRelays.map((relay) => relay.id)).toEqual(['0x112']);
+    await expect(client.getRelaysByRegion('us-east')).resolves.toHaveLength(1);
+  });
+});
+
+describe('RelayDiscovery', () => {
+  it('selects the best relay and caches relay lists', async () => {
+    let now = 10_000;
+    const listRelays = vi.fn().mockResolvedValue([
+      createRelay({ id: '0xrelay-east', region: 'us-east', routingFeeBps: 50, stakeAmountMist: 150_000_000_000n, heartbeatAgeMs: 100 }),
+      createRelay({
+        id: '0xrelay-west',
+        region: 'us-west',
+        routingFeeBps: 10,
+        stakeAmountMist: 80_000_000_000n,
+        heartbeatAgeMs: 100,
+      }),
+      createRelay({
+        id: '0xrelay-stale',
+        region: 'us-east',
+        routingFeeBps: 20,
+        stakeAmountMist: 500_000_000_000n,
+        heartbeatAgeMs: 40_000,
+        isHeartbeatFresh: false,
+      }),
+    ]);
+    const discovery = new RelayDiscovery({ listRelays } as Pick<RelayRegistryClient, 'listRelays'>, {
+      cacheTtlMs: 1_000,
+      heartbeatFreshnessMs: 5_000,
+      now: () => now,
+    });
+
+    const first = await discovery.findBestRelay('routing', 'us-east');
+    const second = await discovery.findBestRelay('routing', 'us-east');
+    now = 12_000;
+    const third = await discovery.findBestRelay('routing', 'us-east');
+
+    expect(first?.id).toBe('0xrelay-east');
+    expect(second?.id).toBe('0xrelay-east');
+    expect(third?.id).toBe('0xrelay-east');
+    expect(listRelays).toHaveBeenCalledTimes(2);
+  });
+});

package/tests/reputation/event-publisher.test.ts

@@ -0,0 +1,70 @@
+import { randomUUID } from 'node:crypto';
+import { mkdir, rm } from 'node:fs/promises';
+import { resolve } from 'node:path';
+
+import { Ed25519Keypair } from '@mysten/sui/keypairs/ed25519';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+import { Ed25519AuthProvider, ReputationEventPublisher } from '../../src/index.js';
+import { serializeReputationEventPayload } from '../../src/reputation/serialization.js';
+
+const createdPaths: string[] = [];
+
+afterEach(async () => {
+  await Promise.all(createdPaths.splice(0).map((path) => rm(path, { recursive: true, force: true })));
+});
+
+async function createTempDir(): Promise<string> {
+  const dir = resolve(process.cwd(), '.test-data', randomUUID());
+  createdPaths.push(dir);
+  await mkdir(dir, { recursive: true });
+  return dir;
+}
+
+describe('ReputationEventPublisher', () => {
+  it('rejects self-authored reputation events', async () => {
+    await createTempDir();
+    const keypair = Ed25519Keypair.generate();
+    const identity = new Ed25519AuthProvider(keypair);
+    const publisher = new ReputationEventPublisher({ store: vi.fn() } as never, identity);
+
+    await expect(publisher.createEvent({
+      type: 'task_completion',
+      subject: identity.getDID(),
+      taskId: 'task-1',
+      outcome: 'success',
+      capability: 'echo',
+    })).rejects.toThrow('Reputation event subject must differ from author.');
+  });
+
+  it('creates signed reputation events and publishes them', async () => {
+    await createTempDir();
+    const keypair = Ed25519Keypair.generate();
+    const identity = new Ed25519AuthProvider(keypair);
+    const blobStore = {
+      store: vi.fn(async () => ({ blobId: 'blob-1', hash: 'hash', checksum: 'hash', contentHash: 'hash', size: 1, storedAt: Date.now() })),
+    } as never;
+    const publisher = new ReputationEventPublisher(blobStore, identity);
+
+    const event = await publisher.createEvent({
+      type: 'task_completion',
+      subject: 'did:mesh:provider',
+      taskId: 'task-1',
+      outcome: 'success',
+      capability: 'echo',
+      rating: 5,
+      latencyMs: 123,
+      paymentAmount: { amount: '42', currency: 'MIST' },
+    });
+
+    expect(event.author).toBe(identity.getDID());
+    expect(event.signature.length).toBeGreaterThan(0);
+    const { signature, ...unsignedEvent } = event;
+    await expect(
+      keypair.getPublicKey().verifyPersonalMessage(serializeReputationEventPayload(unsignedEvent), signature),
+    ).resolves.toBe(true);
+
+    await publisher.publishEvent(event);
+    expect(blobStore.store).toHaveBeenCalledOnce();
+  });
+});

package/tests/reputation/merkle.test.ts

@@ -0,0 +1,44 @@
+import { describe, expect, it } from 'vitest';
+
+import type { ReputationEvent } from '@hivemind-os/collective-types';
+
+import { buildMerkleTree, verifyMerkleProof } from '../../src/index.js';
+
+function createEvent(index: number): ReputationEvent {
+  return {
+    eventId: `event-${index}`,
+    type: 'task_completion',
+    subject: 'did:mesh:provider',
+    author: 'did:mesh:requester',
+    taskId: `task-${index}`,
+    outcome: 'success',
+    capability: 'echo',
+    timestamp: new Date(1_700_000_000_000 + index * 1_000).toISOString(),
+    nonce: `nonce-${index}`,
+    signature: `signature-${index}`,
+  };
+}
+
+describe('Merkle tree', () => {
+  it('builds proofs for multiple leaves', () => {
+    const events = [createEvent(1), createEvent(2), createEvent(3), createEvent(4)];
+    const tree = buildMerkleTree(events);
+
+    expect(verifyMerkleProof(events[2]!, tree.proof(2), tree.root, 2)).toBe(true);
+  });
+
+  it('supports odd numbers of leaves', () => {
+    const events = [createEvent(1), createEvent(2), createEvent(3)];
+    const tree = buildMerkleTree(events);
+
+    expect(verifyMerkleProof(events[2]!, tree.proof(2), tree.root, 2)).toBe(true);
+  });
+
+  it('supports a single leaf', () => {
+    const events = [createEvent(1)];
+    const tree = buildMerkleTree(events);
+
+    expect(tree.proof(0)).toEqual([]);
+    expect(verifyMerkleProof(events[0]!, tree.proof(0), tree.root, 0)).toBe(true);
+  });
+});