@hivemind-os/collective-core 0.2.0

package/tests/staking/client.test.ts

@@ -0,0 +1,286 @@
+import type { Ed25519Keypair } from '@mysten/sui/keypairs/ed25519';
+import { describe, expect, it, vi } from 'vitest';
+
+import { PaymentRail, RegistryClient, StakingClient, type MeshSuiClient, type AgentCard } from '../../src/index.js';
+
+const contractConfig = { packageId: '0x1' };
+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);
+}
+
+function createAgent(overrides: Partial<AgentCard> = {}): AgentCard {
+  return {
+    id: '0xagent-1',
+    owner: '0xowner-1',
+    did: 'did:mesh:agent-1' as AgentCard['did'],
+    name: 'Summarizer',
+    description: 'Summarizes text',
+    capabilities: [
+      {
+        name: 'summarize',
+        description: 'Summarize documents',
+        version: '1.0.0',
+        pricing: {
+          rail: PaymentRail.SUI_ESCROW,
+          amount: 100n,
+          currency: 'MIST',
+        },
+      },
+    ],
+    endpoint: 'mesh://agent/did:mesh:agent-1',
+    active: true,
+    version: 1,
+    registeredAt: 1_000,
+    updatedAt: 1_000,
+    totalTasksCompleted: 1,
+    totalTasksFailed: 0,
+    ...overrides,
+  };
+}
+
+describe('StakingClient', () => {
+  it('builds a deposit stake transaction and returns the new stake id', async () => {
+    const executeTransaction = vi.fn().mockResolvedValue({
+      digest: '0xtx',
+      objectChanges: [],
+      events: [
+        {
+          type: '0x1::staking::StakeDeposited',
+          parsedJson: { stake_id: '0xstake-1' },
+        },
+      ],
+    });
+    const client = new StakingClient(
+      {
+        executeTransaction,
+        queryEvents: vi.fn(),
+        getObject: vi.fn(),
+      } as unknown as MeshSuiClient,
+      contractConfig,
+    );
+
+    const result = await client.depositStake({
+      amountMist: 10_000_000_000n,
+      stakeType: 'agent',
+      signer: {} as Ed25519Keypair,
+    });
+
+    const tx = executeTransaction.mock.calls[0]?.[0];
+    expect(getMoveTargets(tx).some((target) => target.endsWith('::staking::deposit_stake'))).toBe(true);
+    expect(result).toEqual({ stakeId: '0xstake-1', txDigest: '0xtx' });
+  });
+
+  it('parses stake positions from Move objects', async () => {
+    const client = new StakingClient(
+      {
+        executeTransaction: vi.fn(),
+        queryEvents: vi.fn(),
+        getObject: vi.fn().mockResolvedValue({
+          objectId: '0xstake-1',
+          owner: '0xowner-1',
+          stake_type: 0,
+          balance: { value: '10000000000' },
+          staked_at: 123,
+          deactivated_at: 0,
+          slashed_amount: '50',
+        }),
+      } as unknown as MeshSuiClient,
+      contractConfig,
+    );
+
+    const position = await client.getStakePosition('0xstake-1');
+
+    expect(position).toEqual({
+      id: '0xstake-1',
+      owner: '0xowner-1',
+      stakeType: 'agent',
+      balanceMist: 10_000_000_000n,
+      stakedAt: 123,
+      deactivatedAt: 0,
+      slashedAmount: 50n,
+      isActive: true,
+      meetsMinium: true,
+      meetsMinimum: true,
+    });
+  });
+
+  it('returns the best active stake for an owner', async () => {
+    const getObject = vi.fn().mockImplementation(async (id: string) => ({
+      objectId: id,
+      owner: '0xowner-1',
+      stake_type: 0,
+      balance: { value: id === '0xstake-active' ? '12000000000' : '5000000000' },
+      staked_at: id === '0xstake-active' ? 2 : 1,
+      deactivated_at: id === '0xstake-active' ? 0 : 3,
+      slashed_amount: '0',
+    }));
+    const client = new StakingClient(
+      {
+        executeTransaction: vi.fn(),
+        queryEvents: vi.fn().mockResolvedValue({
+          events: [
+            { type: '0x1::staking::StakeDeposited', parsedJson: { owner: '0xowner-1', stake_id: '0xstake-old' } },
+            { type: '0x1::staking::StakeDeposited', parsedJson: { owner: '0xowner-1', stake_id: '0xstake-active' } },
+          ],
+          nextCursor: null,
+          hasMore: false,
+        }),
+        getObject,
+      } as unknown as MeshSuiClient,
+      contractConfig,
+    );
+
+    const position = await client.getStakeByOwner('0xowner-1');
+
+    expect(position?.id).toBe('0xstake-active');
+  });
+
+  it('fails when the deactivation event omits cooldown metadata', async () => {
+    const client = new StakingClient(
+      {
+        executeTransaction: vi.fn().mockResolvedValue({
+          digest: '0xdeactivate',
+          events: [{ type: '0x1::staking::DeactivationStarted', parsedJson: {} }],
+          objectChanges: [],
+        }),
+        queryEvents: vi.fn(),
+        getObject: vi.fn(),
+      } as unknown as MeshSuiClient,
+      contractConfig,
+    );
+
+    await expect(client.startDeactivation({ stakeId: '0x123', signer: {} as Ed25519Keypair })).rejects.toThrow(
+      'DeactivationStarted event did not include a valid cooldown_ends_at.',
+    );
+  });
+
+  it('supports add stake, deactivation, withdrawal, and slashing flows', async () => {
+    const executeTransaction = vi
+      .fn()
+      .mockResolvedValueOnce({ digest: '0xadd', events: [], objectChanges: [] })
+      .mockResolvedValueOnce({
+        digest: '0xdeactivate',
+        events: [{ type: '0x1::staking::DeactivationStarted', parsedJson: { cooldown_ends_at: 1234 } }],
+        objectChanges: [],
+      })
+      .mockResolvedValueOnce({
+        digest: '0xwithdraw',
+        events: [{ type: '0x1::staking::StakeWithdrawn', parsedJson: { amount: '5000' } }],
+        objectChanges: [],
+      })
+      .mockResolvedValueOnce({
+        digest: '0xslash',
+        events: [{ type: '0x1::staking::StakeSlashed', parsedJson: { amount: '25' } }],
+        objectChanges: [],
+      });
+    const client = new StakingClient(
+      {
+        executeTransaction,
+        queryEvents: vi.fn(),
+        getObject: vi.fn(),
+      } as unknown as MeshSuiClient,
+      contractConfig,
+    );
+
+    await expect(client.addStake({ stakeId: '0x123', amountMist: 100n, signer: {} as Ed25519Keypair })).resolves.toEqual({
+      txDigest: '0xadd',
+    });
+    await expect(client.startDeactivation({ stakeId: '0x123', signer: {} as Ed25519Keypair })).resolves.toEqual({
+      cooldownEndsAt: 1234,
+      txDigest: '0xdeactivate',
+    });
+    await expect(client.withdrawStake({ stakeId: '0x123', signer: {} as Ed25519Keypair })).resolves.toEqual({
+      amountReturned: 5000n,
+      txDigest: '0xwithdraw',
+    });
+    await expect(client.slashExpiredEscrow({ stakeId: '0x123', taskId: '0x456', signer: {} as Ed25519Keypair })).resolves.toEqual({
+      slashedAmount: 25n,
+      txDigest: '0xslash',
+    });
+  });
+});
+
+describe('RegistryClient staking discovery', () => {
+  it('ranks staked agents ahead of unstaked peers', async () => {
+    const staked = createAgent({ owner: '0xowner-staked', totalTasksCompleted: 3 });
+    const unstaked = createAgent({
+      id: '0xagent-2',
+      did: 'did:mesh:agent-2' as AgentCard['did'],
+      owner: '0xowner-unstaked',
+      totalTasksCompleted: 3,
+    });
+    const getStakeByOwner = vi.spyOn(StakingClient.prototype, 'getStakeByOwner')
+      .mockResolvedValueOnce(null)
+      .mockResolvedValueOnce({
+        id: '0xstake',
+        owner: staked.owner,
+        stakeType: 'agent',
+        balanceMist: 10_000_000_000n,
+        stakedAt: 1,
+        deactivatedAt: 0,
+        slashedAmount: 0n,
+        isActive: true,
+        meetsMinium: true,
+      });
+
+    const client = new RegistryClient(
+      {
+        executeTransaction: vi.fn(),
+        queryEvents: vi.fn().mockResolvedValue({
+          events: [
+            {
+              id: { txDigest: '0x1', eventSeq: '0' },
+              type: '0x1::registry::AgentRegistered',
+              timestampMs: '1',
+              parsedJson: { card_id: unstaked.id, capabilities: unstaked.capabilities },
+            },
+            {
+              id: { txDigest: '0x2', eventSeq: '1' },
+              type: '0x1::registry::AgentRegistered',
+              timestampMs: '2',
+              parsedJson: { card_id: staked.id, capabilities: staked.capabilities },
+            },
+          ],
+          nextCursor: null,
+          hasMore: false,
+        }),
+        getObject: vi.fn().mockImplementation(async (id: string) => {
+          if (id === staked.id) {
+            return staked;
+          }
+          if (id === unstaked.id) {
+            return unstaked;
+          }
+          throw new Error(`unexpected object ${id}`);
+        }),
+      } as unknown as MeshSuiClient,
+      networkConfig,
+    );
+
+    const results = await client.discoverByCapability('summarize', 10, { sortByReputation: true });
+
+    expect(getStakeByOwner).toHaveBeenCalledTimes(2);
+    expect(results.map((agent) => agent.did)).toEqual([staked.did, unstaked.did]);
+    expect(results[0]?.hasStake).toBe(true);
+  });
+});

package/tests/sui-client.test.ts

@@ -0,0 +1,85 @@
+import type { SuiTransactionBlockResponse } from '@mysten/sui/client';
+import type { Ed25519Keypair } from '@mysten/sui/keypairs/ed25519';
+import { Transaction } from '@mysten/sui/transactions';
+import { describe, expect, it, vi } from 'vitest';
+
+import { MeshSuiClient, SuiTransactionExecutionError } 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 createKeypairStub(): Ed25519Keypair {
+  return {
+    getPublicKey: () => ({
+      toSuiAddress: () => '0x123',
+    }),
+  } as unknown as Ed25519Keypair;
+}
+
+describe('MeshSuiClient', () => {
+  it('throws informative errors for failed transaction effects', async () => {
+    const client = new MeshSuiClient(networkConfig);
+    const signAndExecuteTransaction = vi.fn().mockResolvedValue({ digest: '0xabc' });
+    const waitForTransaction = vi.fn().mockResolvedValue({
+      digest: '0xabc',
+      effects: {
+        status: {
+          status: 'failure',
+          error: 'Insufficient gas',
+        },
+      },
+    } satisfies Partial<SuiTransactionBlockResponse>);
+
+    Reflect.set(client, 'suiClient', {
+      signAndExecuteTransaction,
+      waitForTransaction,
+    });
+
+    const execution = client.executeTransaction(new Transaction(), createKeypairStub());
+
+    await expect(execution).rejects.toThrow(SuiTransactionExecutionError);
+    await expect(execution).rejects.toThrow(/insufficient gas/i);
+  });
+
+  it('retries retryable execution failures before succeeding', async () => {
+    const client = new MeshSuiClient(networkConfig);
+    const signAndExecuteTransaction = vi
+      .fn()
+      .mockResolvedValueOnce({ digest: '0xretry-1' })
+      .mockResolvedValueOnce({ digest: '0xretry-2' });
+    const waitForTransaction = vi
+      .fn()
+      .mockResolvedValueOnce({
+        digest: '0xretry-1',
+        effects: {
+          status: {
+            status: 'failure',
+            error: 'Object lock conflict',
+          },
+        },
+      } satisfies Partial<SuiTransactionBlockResponse>)
+      .mockResolvedValueOnce({
+        digest: '0xretry-2',
+        effects: {
+          status: {
+            status: 'success',
+          },
+        },
+      } satisfies Partial<SuiTransactionBlockResponse>);
+
+    Reflect.set(client, 'suiClient', {
+      signAndExecuteTransaction,
+      waitForTransaction,
+    });
+
+    const response = await client.executeTransaction(new Transaction(), createKeypairStub());
+
+    expect(response.digest).toBe('0xretry-2');
+    expect(signAndExecuteTransaction).toHaveBeenCalledTimes(2);
+    expect(waitForTransaction).toHaveBeenCalledTimes(2);
+  });
+});

package/tests/task.test.ts

@@ -0,0 +1,249 @@
+import type { Ed25519Keypair } from '@mysten/sui/keypairs/ed25519';
+import { describe, expect, it, vi } from 'vitest';
+
+import { PaymentScheme, TaskClient, 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;
+}
+
+describe('TaskClient', () => {
+  it('builds a post task transaction with split coins', async () => {
+    const executeTransaction = vi.fn().mockResolvedValue({
+      digest: '0xtx',
+      objectChanges: [
+        {
+          type: 'created',
+          objectType: '0x1::task::Task',
+          objectId: '0x3',
+        },
+      ],
+    });
+    const client = new TaskClient(
+      {
+        executeTransaction,
+        getObject: vi.fn(),
+      } as unknown as MeshSuiClient,
+      networkConfig,
+    );
+
+    const result = await client.postTask({
+      capability: 'summarize',
+      category: 'analysis',
+      inputBlobId: 'blob-1',
+      agreementHash: 'hash-1',
+      priceMist: 500n,
+      disputeWindowMs: 60_000,
+      expiryHours: 24,
+      keypair: {} as unknown as Ed25519Keypair,
+    });
+
+    const commands = getCommands(executeTransaction.mock.calls[0]?.[0]);
+    const kinds = commands.map((command) => String(command.$kind));
+
+    expect(kinds).toContain('SplitCoins');
+    expect(kinds).toContain('MoveCall');
+    expect(result).toEqual({ txDigest: '0xtx', taskId: '0x3' });
+  });
+
+  it('builds an accept task transaction', async () => {
+    const executeTransaction = vi.fn().mockResolvedValue({ digest: '0xtx' });
+    const client = new TaskClient(
+      {
+        executeTransaction,
+        getObject: vi.fn(),
+      } as unknown as MeshSuiClient,
+      networkConfig,
+    );
+
+    await client.acceptTask({
+      taskId: '0x3',
+      keypair: {} as unknown as Ed25519Keypair,
+    });
+
+    const commands = getCommands(executeTransaction.mock.calls[0]?.[0]);
+    expect(commands[0]?.$kind).toBe('MoveCall');
+  });
+
+  it('builds metered task lifecycle transactions', async () => {
+    const executeTransaction = vi.fn()
+      .mockResolvedValueOnce({
+        digest: '0xpost',
+        objectChanges: [
+          {
+            type: 'created',
+            objectType: '0x1::task::Task',
+            objectId: '0x9',
+          },
+        ],
+      })
+      .mockResolvedValueOnce({ digest: '0xcomplete' })
+      .mockResolvedValueOnce({ digest: '0xrelease' });
+     const client = new TaskClient(
+      {
+        executeTransaction,
+        getObject: vi.fn(),
+      } as unknown as MeshSuiClient,
+      networkConfig,
+    );
+
+    const posted = await client.postMeteredTask({
+      capability: 'summarize',
+      category: 'analysis',
+      inputBlobId: 'blob-1',
+      agreementHash: 'hash-1',
+      maxPriceMist: 900n,
+      unitPriceMist: 300n,
+      disputeWindowMs: 60_000,
+      expiryHours: 24,
+      keypair: {} as unknown as Ed25519Keypair,
+    });
+    await client.completeMeteredTask({
+      taskId: '0x9',
+      resultBlobId: 'blob-2',
+      meteredUnits: 2,
+      verificationHash: 'aa'.repeat(32),
+      keypair: {} as unknown as Ed25519Keypair,
+    });
+    await client.releaseMeteredPayment({
+      taskId: '0x9',
+      keypair: {} as unknown as Ed25519Keypair,
+    });
+
+    expect(posted).toEqual({ txDigest: '0xpost', taskId: '0x9' });
+    const postCommands = getCommands(executeTransaction.mock.calls[0]?.[0]);
+    expect(postCommands.map((command) => String(command.$kind))).toContain('SplitCoins');
+    const completeCommands = getCommands(executeTransaction.mock.calls[1]?.[0]);
+    expect(completeCommands[0]?.$kind).toBe('MoveCall');
+    const releaseCommands = getCommands(executeTransaction.mock.calls[2]?.[0]);
+    expect(releaseCommands[0]?.$kind).toBe('MoveCall');
+  });
+
+  it('parses task objects', async () => {
+    const client = new TaskClient(
+      {
+        executeTransaction: vi.fn(),
+        getObject: vi.fn().mockResolvedValue({
+          id: '0xtask',
+          requester: '0xrequester',
+          provider: '0x0',
+          capability: 'summarize',
+          category: 'analysis',
+          input_blob_id: 'blob-1',
+          price: '500',
+          status: 0,
+          dispute_window_ms: 60_000,
+          created_at: 1_000,
+          expires_at: 2_000,
+          agreement_hash: 'hash-1',
+        }),
+      } as unknown as MeshSuiClient,
+      networkConfig,
+    );
+
+    const task = await client.getTask('0xtask');
+
+    expect(task).toEqual({
+      id: '0xtask',
+      requester: '0xrequester',
+      provider: undefined,
+      capability: 'summarize',
+      category: 'analysis',
+      inputBlobId: 'blob-1',
+      resultBlobId: undefined,
+      price: 500n,
+      paymentScheme: undefined,
+      maxPrice: undefined,
+      meteredUnits: undefined,
+      unitPrice: undefined,
+      verificationHash: undefined,
+      status: TaskStatus.OPEN,
+      disputeWindowMs: 60_000,
+      createdAt: 1_000,
+      acceptedAt: undefined,
+      completedAt: undefined,
+      expiresAt: 2_000,
+      agreementHash: 'hash-1',
+    });
+  });
+
+  it('parses metered task objects', async () => {
+    const client = new TaskClient(
+      {
+        executeTransaction: vi.fn(),
+        getObject: vi.fn().mockResolvedValue({
+          id: '0xmetered',
+          requester: '0xrequester',
+          provider: '0xprovider',
+          capability: 'summarize',
+          category: 'analysis',
+          input_blob_id: 'blob-1',
+          result_blob_id: 'blob-2',
+          price: '600',
+          payment_scheme: 1,
+          max_price: '1000',
+          metered_units: 2,
+          unit_price: '300',
+          verification_hash: Array.from(Buffer.from('aa'.repeat(32), 'hex')),
+          status: 2,
+          dispute_window_ms: 60_000,
+          created_at: 1_000,
+          accepted_at: 1_100,
+          completed_at: 1_200,
+          expires_at: 2_000,
+          agreement_hash: 'hash-1',
+        }),
+      } as unknown as MeshSuiClient,
+      networkConfig,
+    );
+
+    await expect(client.getTask('0xmetered')).resolves.toEqual({
+      id: '0xmetered',
+      requester: '0xrequester',
+      provider: '0xprovider',
+      capability: 'summarize',
+      category: 'analysis',
+      inputBlobId: 'blob-1',
+      resultBlobId: 'blob-2',
+      price: 600n,
+      paymentScheme: PaymentScheme.UPTO,
+      maxPrice: 1000n,
+      meteredUnits: 2,
+      unitPrice: 300n,
+      verificationHash: 'aa'.repeat(32),
+      status: TaskStatus.COMPLETED,
+      disputeWindowMs: 60_000,
+      createdAt: 1_000,
+      acceptedAt: 1_100,
+      completedAt: 1_200,
+      expiresAt: 2_000,
+      agreementHash: 'hash-1',
+    });
+  });
+
+  it('rejects invalid task ids before submitting task mutations', async () => {
+    const executeTransaction = vi.fn();
+    const client = new TaskClient(
+      {
+        executeTransaction,
+        getObject: vi.fn(),
+      } as unknown as MeshSuiClient,
+      networkConfig,
+    );
+
+    await expect(
+      client.acceptTask({
+        taskId: 'not-an-object-id',
+        keypair: {} as unknown as Ed25519Keypair,
+      }),
+    ).rejects.toThrow('taskId must be a 0x-prefixed hex object id.');
+    expect(executeTransaction).not.toHaveBeenCalled();
+  });
+});

package/tests/tx-helpers.test.ts

@@ -0,0 +1,70 @@
+import { describe, expect, it } from 'vitest';
+
+import {
+  buildClaimPaymentTx,
+  buildCompleteMeteredTaskTx,
+  buildOpenDisputeTx,
+  buildPostMeteredTaskTx,
+  buildReleaseMeteredPaymentTx,
+} from '../src/sui/tx-helpers.js';
+
+describe('tx-helpers object id validation', () => {
+  it('rejects all-zero object ids while preserving short test ids', () => {
+    expect(() => buildClaimPaymentTx({ packageId: '0x1', taskId: '0x3' })).not.toThrow();
+    expect(() => buildClaimPaymentTx({ packageId: '0x1', taskId: '0x0' })).toThrow(
+      'taskId must be a 0x-prefixed hex object id.',
+    );
+  });
+
+  it('rejects object ids longer than 32 bytes', () => {
+    expect(() => buildClaimPaymentTx({ packageId: `0x${'1'.repeat(65)}`, taskId: '0x3' })).toThrow(
+      'packageId must be a 0x-prefixed hex object id.',
+    );
+  });
+
+  it('rejects zero arbitrator addresses for dispute opening', () => {
+    expect(() => buildOpenDisputeTx({
+      packageId: '0x1',
+      taskId: '0x3',
+      evidenceBlobId: 'walrus:evidence',
+      proposedSplitMist: 1n,
+      arbitratorAddress: '0x0',
+    })).toThrow('arbitratorAddress must be a 0x-prefixed hex object id.');
+  });
+
+  it('builds metered task transactions', () => {
+    expect(() => buildPostMeteredTaskTx({
+      packageId: '0x1',
+      registryId: '0x2',
+      capability: 'summarize',
+      category: 'analysis',
+      inputBlobId: 'blob-1',
+      agreementHash: 'hash-1',
+      maxPriceMist: 10n,
+      unitPriceMist: 2n,
+      disputeWindowMs: 60_000,
+      expiryHours: 24,
+    })).not.toThrow();
+    expect(() => buildCompleteMeteredTaskTx({
+      packageId: '0x1',
+      taskId: '0x3',
+      resultBlobId: 'blob-2',
+      meteredUnits: 2,
+      verificationHash: 'aa'.repeat(32),
+    })).not.toThrow();
+    expect(() => buildReleaseMeteredPaymentTx({
+      packageId: '0x1',
+      taskId: '0x3',
+    })).not.toThrow();
+  });
+
+  it('rejects invalid metered completion hashes', () => {
+    expect(() => buildCompleteMeteredTaskTx({
+      packageId: '0x1',
+      taskId: '0x3',
+      resultBlobId: 'blob-2',
+      meteredUnits: 2,
+      verificationHash: 'xyz',
+    })).toThrow('verificationHash must be an even-length hex string.');
+  });
+});