easctl 0.1.0

package/src/__tests__/commands/get-attestation.test.ts

@@ -0,0 +1,164 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+const mockGetAttestation = vi.fn();
+const mockGetSchema = vi.fn();
+const mockClient = {
+  eas: { getAttestation: mockGetAttestation },
+  schemaRegistry: { getSchema: mockGetSchema },
+};
+
+vi.mock('../../client.js', () => ({
+  createReadOnlyEASClient: vi.fn(() => mockClient),
+}));
+
+vi.mock('../../output.js', () => ({
+  output: vi.fn(),
+  handleError: vi.fn(),
+}));
+
+vi.mock('../../validation.js', () => ({
+  validateBytes32: vi.fn(),
+}));
+
+const mockDecodeData = vi.fn();
+
+vi.mock('@ethereum-attestation-service/eas-sdk', () => ({
+  SchemaEncoder: class MockSchemaEncoder {
+    decodeData = mockDecodeData;
+  },
+}));
+
+import { getAttestationCommand } from '../../commands/get-attestation.js';
+import { output, handleError } from '../../output.js';
+
+const mockAttestation = {
+  uid: '0xuid',
+  schema: '0xschema',
+  attester: '0xattester',
+  recipient: '0xrecipient',
+  refUID: '0xref',
+  revocable: true,
+  revocationTime: 0n,
+  expirationTime: 0n,
+  time: 1700000000n,
+  data: '0xdata',
+};
+
+describe('get-attestation command', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockGetAttestation.mockResolvedValue(mockAttestation);
+  });
+
+  async function runCommand(args: string[]) {
+    await getAttestationCommand.parseAsync(['node', 'test', ...args]);
+  }
+
+  it('gets attestation by uid', async () => {
+    await runCommand(['-u', '0xuid']);
+
+    expect(mockGetAttestation).toHaveBeenCalledWith('0xuid');
+    expect(output).toHaveBeenCalledWith({
+      success: true,
+      data: expect.objectContaining({
+        uid: '0xuid',
+        schema: '0xschema',
+        attester: '0xattester',
+        recipient: '0xrecipient',
+        revocationTime: 0,
+        expirationTime: 0,
+        time: 1700000000,
+        data: '0xdata',
+      }),
+    });
+  });
+
+  it('decodes data when --decode is provided with schema string', async () => {
+    mockDecodeData.mockReturnValue([
+      { name: 'score', type: 'uint256', value: { value: 100n } },
+    ]);
+
+    await runCommand(['-u', '0xuid', '--decode', 'uint256 score']);
+
+    expect(mockGetSchema).not.toHaveBeenCalled();
+    const outputCall = (output as any).mock.calls[0][0];
+    expect(outputCall.data.decodedData).toEqual([
+      { name: 'score', type: 'uint256', value: '100' },
+    ]);
+  });
+
+  it('auto-fetches schema when --decode is passed without value', async () => {
+    mockGetSchema.mockResolvedValue({ schema: 'uint256 score', uid: '0xschema', resolver: '0x0', revocable: true });
+    mockDecodeData.mockReturnValue([
+      { name: 'score', type: 'uint256', value: { value: 42n } },
+    ]);
+
+    await runCommand(['-u', '0xuid', '--decode']);
+
+    expect(mockGetSchema).toHaveBeenCalledWith({ uid: '0xschema' });
+    const outputCall = (output as any).mock.calls[0][0];
+    expect(outputCall.data.decodedData).toEqual([
+      { name: 'score', type: 'uint256', value: '42' },
+    ]);
+  });
+
+  it('adds decodeError when auto-fetch schema fails', async () => {
+    mockGetSchema.mockRejectedValue(new Error('schema not found'));
+
+    await runCommand(['-u', '0xuid', '--decode']);
+
+    const outputCall = (output as any).mock.calls[0][0];
+    expect(outputCall.data.decodeError).toBe('schema not found');
+    expect(outputCall.data.decodedData).toBeUndefined();
+  });
+
+  it('converts bigint values to strings in decoded data', async () => {
+    mockDecodeData.mockReturnValue([
+      { name: 'amount', type: 'uint256', value: { value: 999999999999999999n } },
+    ]);
+
+    await runCommand(['-u', '0xuid', '--decode', 'uint256 amount']);
+
+    const outputCall = (output as any).mock.calls[0][0];
+    expect(outputCall.data.decodedData[0].value).toBe('999999999999999999');
+  });
+
+  it('passes through non-bigint decoded values', async () => {
+    mockDecodeData.mockReturnValue([
+      { name: 'label', type: 'string', value: { value: 'hello' } },
+    ]);
+
+    await runCommand(['-u', '0xuid', '--decode', 'string label']);
+
+    const outputCall = (output as any).mock.calls[0][0];
+    expect(outputCall.data.decodedData[0].value).toBe('hello');
+  });
+
+  it('adds decodeError on decode failure instead of throwing', async () => {
+    mockDecodeData.mockImplementation(() => {
+      throw new Error('decode failed');
+    });
+
+    await runCommand(['-u', '0xuid', '--decode', 'bad schema']);
+
+    const outputCall = (output as any).mock.calls[0][0];
+    expect(outputCall.data.decodeError).toBe('decode failed');
+    expect(outputCall.data.decodedData).toBeUndefined();
+  });
+
+  it('passes SDK errors to handleError', async () => {
+    mockGetAttestation.mockRejectedValue(new Error('network error'));
+    await runCommand(['-u', '0xuid']);
+    expect(handleError).toHaveBeenCalledWith(expect.any(Error));
+    const err = (handleError as any).mock.calls[0][0] as Error;
+    expect(err.message).toBe('network error');
+  });
+
+  it('does not include decodedData when --decode not provided', async () => {
+    await runCommand(['-u', '0xuid']);
+
+    const outputCall = (output as any).mock.calls[0][0];
+    expect(outputCall.data.decodedData).toBeUndefined();
+    expect(outputCall.data.decodeError).toBeUndefined();
+  });
+});

package/src/__tests__/commands/multi-attest.test.ts

@@ -0,0 +1,166 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+const mockEstimateGas = vi.fn().mockResolvedValue(50000n);
+const mockWait = vi.fn();
+const mockTx = { wait: mockWait, receipt: null as any, estimateGas: mockEstimateGas };
+const mockMultiAttest = vi.fn().mockResolvedValue(mockTx);
+const mockClient = {
+  eas: { multiAttest: mockMultiAttest },
+  address: '0xAttester',
+};
+
+vi.mock('../../client.js', () => ({
+  createEASClient: vi.fn(() => mockClient),
+}));
+
+vi.mock('../../output.js', () => ({
+  output: vi.fn(),
+  handleError: vi.fn(),
+}));
+
+vi.mock('../../stdin.js', () => ({
+  resolveInput: vi.fn((v: string) => Promise.resolve(v)),
+}));
+
+const mockEncodeData = vi.fn().mockReturnValue('0xencoded');
+
+vi.mock('@ethereum-attestation-service/eas-sdk', () => ({
+  SchemaEncoder: class MockSchemaEncoder {
+    encodeData = mockEncodeData;
+  },
+  NO_EXPIRATION: 0n,
+  ZERO_BYTES32: '0x0000000000000000000000000000000000000000000000000000000000000000',
+}));
+
+import { multiAttestCommand } from '../../commands/multi-attest.js';
+import { output, handleError } from '../../output.js';
+
+describe('multi-attest command', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockWait.mockImplementation(async () => {
+      mockTx.receipt = { hash: '0xtxhash456' };
+      return ['0xuid1', '0xuid2'];
+    });
+  });
+
+  async function runCommand(args: string[]) {
+    await multiAttestCommand.parseAsync(['node', 'test', ...args]);
+  }
+
+  it('processes single attestation input', async () => {
+    const input = JSON.stringify([
+      { schema: '0xschema1', data: [{ name: 'x', type: 'uint8', value: '1' }] },
+    ]);
+
+    await runCommand(['-i', input]);
+
+    expect(mockEncodeData).toHaveBeenCalledWith([
+      { name: 'x', type: 'uint8', value: '1' },
+    ]);
+    expect(mockMultiAttest).toHaveBeenCalledWith([
+      {
+        schema: '0xschema1',
+        data: [
+          expect.objectContaining({
+            recipient: '0x0000000000000000000000000000000000000000',
+            expirationTime: 0n,
+            revocable: true,
+            refUID: '0x0000000000000000000000000000000000000000000000000000000000000000',
+            data: '0xencoded',
+            value: 0n,
+          }),
+        ],
+      },
+    ]);
+  });
+
+  it('groups attestations by schema', async () => {
+    const input = JSON.stringify([
+      { schema: '0xschemaA', data: [{ name: 'x', type: 'uint8', value: '1' }] },
+      { schema: '0xschemaB', data: [{ name: 'y', type: 'uint8', value: '2' }] },
+      { schema: '0xschemaA', data: [{ name: 'x', type: 'uint8', value: '3' }] },
+    ]);
+
+    await runCommand(['-i', input]);
+
+    const groups = mockMultiAttest.mock.calls[0][0];
+    expect(groups).toHaveLength(2);
+    const groupA = groups.find((g: any) => g.schema === '0xschemaA');
+    expect(groupA.data).toHaveLength(2);
+  });
+
+  it('handles invalid JSON in --input', async () => {
+    await runCommand(['-i', 'not-json']);
+    expect(handleError).toHaveBeenCalledWith(expect.any(Error));
+    const err = (handleError as any).mock.calls[0][0] as Error;
+    expect(err.message).toContain('Invalid JSON in --input');
+  });
+
+  it('uses custom values when provided', async () => {
+    const input = JSON.stringify([
+      {
+        schema: '0xschema1',
+        recipient: '0xCustomRecipient',
+        expirationTime: '1700000000',
+        revocable: false,
+        refUID: '0xref',
+        value: '500',
+        data: [{ name: 'x', type: 'uint8', value: '1' }],
+      },
+    ]);
+
+    await runCommand(['-i', input]);
+
+    const attestData = mockMultiAttest.mock.calls[0][0][0].data[0];
+    expect(attestData.recipient).toBe('0xCustomRecipient');
+    expect(attestData.expirationTime).toBe(1700000000n);
+    expect(attestData.revocable).toBe(false);
+    expect(attestData.refUID).toBe('0xref');
+    expect(attestData.value).toBe(500n);
+  });
+
+  it('passes SDK errors to handleError', async () => {
+    mockMultiAttest.mockRejectedValueOnce(new Error('tx failed'));
+    const input = JSON.stringify([
+      { schema: '0xschema1', data: [{ name: 'x', type: 'uint8', value: '1' }] },
+    ]);
+    await runCommand(['-i', input]);
+    expect(handleError).toHaveBeenCalledWith(expect.any(Error));
+    const err = (handleError as any).mock.calls[0][0] as Error;
+    expect(err.message).toBe('tx failed');
+  });
+
+  it('outputs uids, count, and txHash on success', async () => {
+    const input = JSON.stringify([
+      { schema: '0xschema1', data: [{ name: 'x', type: 'uint8', value: '1' }] },
+    ]);
+
+    await runCommand(['-i', input]);
+
+    expect(output).toHaveBeenCalledWith({
+      success: true,
+      data: {
+        uids: ['0xuid1', '0xuid2'],
+        count: 2,
+        txHash: '0xtxhash456',
+        chain: 'ethereum',
+      },
+    });
+  });
+
+  it('estimates gas in dry-run mode without sending', async () => {
+    const input = JSON.stringify([
+      { schema: '0xschema1', data: [{ name: 'x', type: 'uint8', value: '1' }] },
+    ]);
+
+    await runCommand(['-i', input, '--dry-run']);
+
+    expect(mockEstimateGas).toHaveBeenCalled();
+    expect(mockWait).not.toHaveBeenCalled();
+    expect(output).toHaveBeenCalledWith({
+      success: true,
+      data: { dryRun: true, estimatedGas: '50000', chain: 'ethereum' },
+    });
+  });
+});

package/src/__tests__/commands/multi-revoke.test.ts

@@ -0,0 +1,114 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+const mockEstimateGas = vi.fn().mockResolvedValue(40000n);
+const mockWait = vi.fn();
+const mockTx = { wait: mockWait, receipt: null as any, estimateGas: mockEstimateGas };
+const mockMultiRevoke = vi.fn().mockResolvedValue(mockTx);
+const mockClient = {
+  eas: { multiRevoke: mockMultiRevoke },
+};
+
+vi.mock('../../client.js', () => ({
+  createEASClient: vi.fn(() => mockClient),
+}));
+
+vi.mock('../../output.js', () => ({
+  output: vi.fn(),
+  handleError: vi.fn(),
+}));
+
+vi.mock('../../stdin.js', () => ({
+  resolveInput: vi.fn((v: string) => Promise.resolve(v)),
+}));
+
+import { multiRevokeCommand } from '../../commands/multi-revoke.js';
+import { output, handleError } from '../../output.js';
+
+describe('multi-revoke command', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockWait.mockImplementation(async () => {
+      mockTx.receipt = { hash: '0xmultirevokehash' };
+      return undefined;
+    });
+  });
+
+  async function runCommand(args: string[]) {
+    await multiRevokeCommand.parseAsync(['node', 'test', ...args]);
+  }
+
+  it('revokes multiple attestations grouped by schema', async () => {
+    const input = JSON.stringify([
+      { schema: '0xschemaA', uid: '0xuid1' },
+      { schema: '0xschemaB', uid: '0xuid2' },
+      { schema: '0xschemaA', uid: '0xuid3' },
+    ]);
+
+    await runCommand(['-i', input]);
+
+    const groups = mockMultiRevoke.mock.calls[0][0];
+    expect(groups).toHaveLength(2);
+    const groupA = groups.find((g: any) => g.schema === '0xschemaA');
+    expect(groupA.data).toHaveLength(2);
+    expect(groupA.data[0]).toEqual({ uid: '0xuid1', value: 0n });
+    expect(groupA.data[1]).toEqual({ uid: '0xuid3', value: 0n });
+  });
+
+  it('outputs revoked count and txHash', async () => {
+    const input = JSON.stringify([
+      { schema: '0xschema', uid: '0xuid1' },
+      { schema: '0xschema', uid: '0xuid2' },
+    ]);
+
+    await runCommand(['-i', input]);
+
+    expect(output).toHaveBeenCalledWith({
+      success: true,
+      data: {
+        revoked: 2,
+        txHash: '0xmultirevokehash',
+        chain: 'ethereum',
+      },
+    });
+  });
+
+  it('handles invalid JSON in --input', async () => {
+    await runCommand(['-i', 'not-json']);
+    expect(handleError).toHaveBeenCalledWith(expect.any(Error));
+    const err = (handleError as any).mock.calls[0][0] as Error;
+    expect(err.message).toContain('Invalid JSON in --input');
+  });
+
+  it('passes custom value as BigInt', async () => {
+    const input = JSON.stringify([
+      { schema: '0xschema', uid: '0xuid1', value: '500' },
+    ]);
+
+    await runCommand(['-i', input]);
+
+    const data = mockMultiRevoke.mock.calls[0][0][0].data[0];
+    expect(data.value).toBe(500n);
+  });
+
+  it('passes SDK errors to handleError', async () => {
+    mockMultiRevoke.mockRejectedValueOnce(new Error('tx failed'));
+    const input = JSON.stringify([{ schema: '0xschema', uid: '0xuid1' }]);
+    await runCommand(['-i', input]);
+    expect(handleError).toHaveBeenCalledWith(expect.any(Error));
+    const err = (handleError as any).mock.calls[0][0] as Error;
+    expect(err.message).toBe('tx failed');
+  });
+
+  it('estimates gas in dry-run mode without sending', async () => {
+    const input = JSON.stringify([{ schema: '0xschema', uid: '0xuid1' }]);
+
+    await runCommand(['-i', input, '--dry-run']);
+
+    expect(mockEstimateGas).toHaveBeenCalled();
+    expect(mockWait).not.toHaveBeenCalled();
+    expect(output).toHaveBeenCalledWith({
+      success: true,
+      data: { dryRun: true, estimatedGas: '40000', chain: 'ethereum' },
+    });
+  });
+});

package/src/__tests__/commands/multi-timestamp.test.ts

@@ -0,0 +1,88 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+const mockEstimateGas = vi.fn().mockResolvedValue(35000n);
+const mockWait = vi.fn();
+const mockTx = { wait: mockWait, receipt: null as any, estimateGas: mockEstimateGas };
+const mockMultiTimestamp = vi.fn().mockResolvedValue(mockTx);
+const mockClient = {
+  eas: { multiTimestamp: mockMultiTimestamp },
+};
+
+vi.mock('../../client.js', () => ({
+  createEASClient: vi.fn(() => mockClient),
+}));
+
+vi.mock('../../output.js', () => ({
+  output: vi.fn(),
+  handleError: vi.fn(),
+}));
+
+vi.mock('../../stdin.js', () => ({
+  resolveInput: vi.fn((v: string) => Promise.resolve(v)),
+}));
+
+import { multiTimestampCommand } from '../../commands/multi-timestamp.js';
+import { output, handleError } from '../../output.js';
+
+describe('multi-timestamp command', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockWait.mockImplementation(async () => {
+      mockTx.receipt = { hash: '0xmultitshash' };
+      return [1700000000n, 1700000001n];
+    });
+  });
+
+  async function runCommand(args: string[]) {
+    await multiTimestampCommand.parseAsync(['node', 'test', ...args]);
+  }
+
+  it('timestamps multiple data items', async () => {
+    const data = JSON.stringify(['0xdata1', '0xdata2']);
+
+    await runCommand(['-d', data]);
+
+    expect(mockMultiTimestamp).toHaveBeenCalledWith(['0xdata1', '0xdata2']);
+    expect(output).toHaveBeenCalledWith({
+      success: true,
+      data: {
+        timestamps: ['1700000000', '1700000001'],
+        count: 2,
+        txHash: '0xmultitshash',
+        chain: 'ethereum',
+      },
+    });
+  });
+
+  it('handles invalid JSON in --data', async () => {
+    await runCommand(['-d', 'not-json']);
+    expect(handleError).toHaveBeenCalledWith(expect.any(Error));
+    const err = (handleError as any).mock.calls[0][0] as Error;
+    expect(err.message).toContain('Invalid JSON in --data');
+  });
+
+  it('passes SDK errors to handleError', async () => {
+    mockMultiTimestamp.mockRejectedValueOnce(new Error('tx failed'));
+    await runCommand(['-d', '["0xdata1"]']);
+    expect(handleError).toHaveBeenCalledWith(expect.any(Error));
+    const err = (handleError as any).mock.calls[0][0] as Error;
+    expect(err.message).toBe('tx failed');
+  });
+
+  it('uses specified chain', async () => {
+    const { createEASClient } = await import('../../client.js');
+    await runCommand(['-d', '["0xdata1"]', '-c', 'base']);
+    expect(createEASClient).toHaveBeenCalledWith('base', undefined);
+  });
+
+  it('estimates gas in dry-run mode without sending', async () => {
+    await runCommand(['-d', '["0xdata1"]', '--dry-run']);
+
+    expect(mockEstimateGas).toHaveBeenCalled();
+    expect(mockWait).not.toHaveBeenCalled();
+    expect(output).toHaveBeenCalledWith({
+      success: true,
+      data: { dryRun: true, estimatedGas: '35000', chain: 'ethereum' },
+    });
+  });
+});