easctl 0.1.0

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

@@ -0,0 +1,217 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+const mockSignOffchainAttestation = vi.fn().mockResolvedValue({
+  uid: '0xoffchainuid',
+  sig: '0xsig',
+});
+const mockGetOffchain = vi.fn().mockResolvedValue({
+  signOffchainAttestation: mockSignOffchainAttestation,
+});
+const mockSigner = { address: '0xSignerAddr' };
+const mockClient = {
+  eas: { getOffchain: mockGetOffchain },
+  signer: mockSigner,
+  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)),
+}));
+
+vi.mock('../../validation.js', () => ({
+  validateAddress: vi.fn(),
+  validateBytes32: vi.fn(),
+}));
+
+vi.mock('../../graphql.js', () => ({
+  EASSCAN_URLS: {
+    ethereum: 'https://easscan.org',
+    base: 'https://base.easscan.org',
+    sepolia: 'https://sepolia.easscan.org',
+  },
+}));
+
+const mockEncodeData = vi.fn().mockReturnValue('0xencoded');
+
+vi.mock('@ethereum-attestation-service/eas-sdk', () => ({
+  SchemaEncoder: class MockSchemaEncoder {
+    encodeData = (...args: any[]) => mockEncodeData(...args);
+  },
+  NO_EXPIRATION: 0n,
+  ZERO_BYTES32: '0x0000000000000000000000000000000000000000000000000000000000000000',
+  createOffchainURL: vi.fn().mockReturnValue('/offchain/url/123'),
+}));
+
+import { offchainAttestCommand } from '../../commands/offchain-attest.js';
+import { createEASClient } from '../../client.js';
+import { output, handleError } from '../../output.js';
+import { createOffchainURL } from '@ethereum-attestation-service/eas-sdk';
+
+describe('offchain-attest command', () => {
+  beforeEach(() => vi.clearAllMocks());
+
+  async function runCommand(args: string[]) {
+    await offchainAttestCommand.parseAsync(['node', 'test', ...args]);
+  }
+
+  it('creates offchain attestation with correct signing args', async () => {
+    await runCommand([
+      '-s', '0xschema',
+      '-d', '[{"name":"x","type":"uint8","value":"1"}]',
+      '-r', '0xRecipient',
+    ]);
+
+    expect(mockGetOffchain).toHaveBeenCalled();
+    expect(mockEncodeData).toHaveBeenCalledWith([
+      { name: 'x', type: 'uint8', value: '1' },
+    ]);
+
+    // Verify signOffchainAttestation was called with correct params
+    const signCall = mockSignOffchainAttestation.mock.calls[0];
+    const params = signCall[0];
+    expect(params.schema).toBe('0xschema');
+    expect(params.recipient).toBe('0xRecipient');
+    expect(params.expirationTime).toBe(0n); // NO_EXPIRATION
+    expect(params.revocable).toBe(true);
+    expect(params.refUID).toBe('0x0000000000000000000000000000000000000000000000000000000000000000');
+    expect(params.data).toBe('0xencoded');
+    expect(typeof params.time).toBe('bigint');
+    expect(params.time).toBeGreaterThan(0n);
+
+    // Verify signer was passed
+    expect(signCall[1]).toBe(mockSigner);
+  });
+
+  it('passes createOffchainURL the correct package', async () => {
+    const signedAttestation = { uid: '0xoffchainuid', sig: '0xsig' };
+    mockSignOffchainAttestation.mockResolvedValueOnce(signedAttestation);
+
+    await runCommand([
+      '-s', '0xschema',
+      '-d', '[{"name":"x","type":"uint8","value":"1"}]',
+    ]);
+
+    expect(createOffchainURL).toHaveBeenCalledWith({
+      sig: signedAttestation,
+      signer: '0xAttester',
+    });
+  });
+
+  it('outputs uid, attester, chain, and offchainUrl', async () => {
+    await runCommand([
+      '-s', '0xschema',
+      '-d', '[{"name":"x","type":"uint8","value":"1"}]',
+    ]);
+
+    expect(output).toHaveBeenCalledWith({
+      success: true,
+      data: expect.objectContaining({
+        uid: '0xoffchainuid',
+        attester: '0xAttester',
+        chain: 'ethereum',
+        offchainUrl: 'https://easscan.org/offchain/url/123',
+      }),
+    });
+  });
+
+  it('handles invalid JSON in --data', async () => {
+    await runCommand(['-s', '0xschema', '-d', '{bad 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('uses chain-specific EASSCAN host', async () => {
+    await runCommand([
+      '-s', '0xschema',
+      '-d', '[{"name":"x","type":"uint8","value":"1"}]',
+      '-c', 'base',
+    ]);
+
+    expect(output).toHaveBeenCalledWith({
+      success: true,
+      data: expect.objectContaining({
+        offchainUrl: 'https://base.easscan.org/offchain/url/123',
+      }),
+    });
+  });
+
+  it('passes --no-revocable as false to signing', async () => {
+    await runCommand([
+      '-s', '0xschema',
+      '-d', '[{"name":"x","type":"uint8","value":"1"}]',
+      '--no-revocable',
+    ]);
+
+    const params = mockSignOffchainAttestation.mock.calls[0][0];
+    expect(params.revocable).toBe(false);
+  });
+
+  it('passes non-zero expiration as BigInt', async () => {
+    await runCommand([
+      '-s', '0xschema',
+      '-d', '[{"name":"x","type":"uint8","value":"1"}]',
+      '--expiration', '1700000000',
+    ]);
+
+    const params = mockSignOffchainAttestation.mock.calls[0][0];
+    expect(params.expirationTime).toBe(1700000000n);
+  });
+
+  it('uses custom chain and rpc-url', async () => {
+    await runCommand([
+      '-s', '0xschema',
+      '-d', '[{"name":"x","type":"uint8","value":"1"}]',
+      '-c', 'sepolia',
+      '--rpc-url', 'https://custom.rpc',
+    ]);
+
+    expect(createEASClient).toHaveBeenCalledWith('sepolia', 'https://custom.rpc');
+  });
+
+  it('passes --ref-uid to signing params', async () => {
+    await runCommand([
+      '-s', '0xschema',
+      '-d', '[{"name":"x","type":"uint8","value":"1"}]',
+      '--ref-uid', '0xreferenceduid',
+    ]);
+
+    const params = mockSignOffchainAttestation.mock.calls[0][0];
+    expect(params.refUID).toBe('0xreferenceduid');
+  });
+
+  it('includes full attestation object in output', async () => {
+    const signedAttestation = { uid: '0xoffchainuid', sig: '0xsig', message: {} };
+    mockSignOffchainAttestation.mockResolvedValueOnce(signedAttestation);
+
+    await runCommand([
+      '-s', '0xschema',
+      '-d', '[{"name":"x","type":"uint8","value":"1"}]',
+    ]);
+
+    const outputCall = (output as any).mock.calls[0][0];
+    expect(outputCall.data.attestation).toBe(signedAttestation);
+  });
+
+  it('passes SDK errors to handleError', async () => {
+    mockGetOffchain.mockRejectedValueOnce(new Error('network unavailable'));
+
+    await runCommand([
+      '-s', '0xschema',
+      '-d', '[{"name":"x","type":"uint8","value":"1"}]',
+    ]);
+
+    expect(handleError).toHaveBeenCalledWith(expect.any(Error));
+    const err = (handleError as any).mock.calls[0][0] as Error;
+    expect(err.message).toBe('network unavailable');
+  });
+});

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

@@ -0,0 +1,84 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+vi.mock('../../graphql.js', () => ({
+  graphqlQuery: vi.fn(),
+  QUERIES: {
+    getAttestation: 'query GetAttestation($id: String!) { attestation(where: { id: $id }) { id } }',
+  },
+}));
+
+vi.mock('../../output.js', () => ({
+  output: vi.fn(),
+  handleError: vi.fn(),
+}));
+
+vi.mock('../../validation.js', () => ({
+  validateBytes32: vi.fn(),
+}));
+
+import { queryAttestationCommand } from '../../commands/query-attestation.js';
+import { graphqlQuery, QUERIES } from '../../graphql.js';
+import { output, handleError } from '../../output.js';
+
+describe('query-attestation command', () => {
+  beforeEach(() => vi.clearAllMocks());
+
+  async function runCommand(args: string[]) {
+    await queryAttestationCommand.parseAsync(['node', 'test', ...args]);
+  }
+
+  it('queries and returns attestation', async () => {
+    (graphqlQuery as any).mockResolvedValue({
+      attestation: { id: '0xatt', attester: '0xAttester', data: '0xdata' },
+    });
+
+    await runCommand(['-u', '0xatt']);
+
+    expect(graphqlQuery).toHaveBeenCalledWith('ethereum', QUERIES.getAttestation, { id: '0xatt' });
+    expect(output).toHaveBeenCalledWith({
+      success: true,
+      data: expect.objectContaining({ id: '0xatt', attester: '0xAttester' }),
+    });
+  });
+
+  it('parses decodedDataJson when present', async () => {
+    (graphqlQuery as any).mockResolvedValue({
+      attestation: {
+        id: '0xatt',
+        decodedDataJson: '[{"name":"score","type":"uint256","value":{"value":"100"}}]',
+      },
+    });
+
+    await runCommand(['-u', '0xatt']);
+
+    const outputCall = (output as any).mock.calls[0][0];
+    expect(outputCall.data.decodedData).toEqual([
+      { name: 'score', type: 'uint256', value: { value: '100' } },
+    ]);
+  });
+
+  it('keeps raw data when decodedDataJson is invalid JSON', async () => {
+    (graphqlQuery as any).mockResolvedValue({
+      attestation: {
+        id: '0xatt',
+        decodedDataJson: 'not-json{{{',
+      },
+    });
+
+    await runCommand(['-u', '0xatt']);
+
+    const outputCall = (output as any).mock.calls[0][0];
+    expect(outputCall.data.decodedData).toBeUndefined();
+    expect(outputCall.data.decodedDataJson).toBe('not-json{{{');
+  });
+
+  it('throws when attestation not found', async () => {
+    (graphqlQuery as any).mockResolvedValue({ attestation: null });
+
+    await runCommand(['-u', '0xmissing']);
+
+    expect(handleError).toHaveBeenCalledWith(expect.any(Error));
+    const err = (handleError as any).mock.calls[0][0] as Error;
+    expect(err.message).toContain('not found');
+  });
+});

package/src/__tests__/commands/query-attestations.test.ts

@@ -0,0 +1,156 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+vi.mock('../../graphql.js', () => ({
+  graphqlQuery: vi.fn(),
+  QUERIES: {
+    getAttestationsBySchema: 'query BySchema',
+    getAttestationsByAttester: 'query ByAttester',
+  },
+}));
+
+vi.mock('../../output.js', () => ({
+  output: vi.fn(),
+  handleError: vi.fn(),
+}));
+
+vi.mock('../../validation.js', () => ({
+  validateAddress: vi.fn(),
+  validateBytes32: vi.fn(),
+}));
+
+import { queryAttestationsCommand } from '../../commands/query-attestations.js';
+import { graphqlQuery, QUERIES } from '../../graphql.js';
+import { output, handleError } from '../../output.js';
+
+describe('query-attestations command', () => {
+  beforeEach(() => vi.clearAllMocks());
+
+  async function runCommand(args: string[]) {
+    await queryAttestationsCommand.parseAsync(['node', 'test', ...args]);
+  }
+
+  it('queries by schema with default skip', async () => {
+    (graphqlQuery as any).mockResolvedValue({
+      attestations: [{ id: '0x1' }, { id: '0x2' }],
+    });
+
+    await runCommand(['-s', '0xschema']);
+
+    expect(graphqlQuery).toHaveBeenCalledWith('ethereum', QUERIES.getAttestationsBySchema, {
+      schemaId: '0xschema',
+      take: 10,
+      skip: 0,
+    });
+    expect(output).toHaveBeenCalledWith({
+      success: true,
+      data: { count: 2, attestations: expect.any(Array) },
+    });
+  });
+
+  it('queries by attester with default skip', async () => {
+    (graphqlQuery as any).mockResolvedValue({
+      attestations: [{ id: '0x1' }],
+    });
+
+    await runCommand(['-a', '0xAttester']);
+
+    expect(graphqlQuery).toHaveBeenCalledWith('ethereum', QUERIES.getAttestationsByAttester, {
+      attester: '0xAttester',
+      take: 10,
+      skip: 0,
+    });
+  });
+
+  it('passes skip for pagination', async () => {
+    (graphqlQuery as any).mockResolvedValue({ attestations: [] });
+
+    await runCommand(['-s', '0xschema', '--skip', '20']);
+
+    expect(graphqlQuery).toHaveBeenCalledWith(
+      'ethereum',
+      expect.any(String),
+      expect.objectContaining({ skip: 20 })
+    );
+  });
+
+  it('schema takes precedence when both provided', async () => {
+    (graphqlQuery as any).mockResolvedValue({ attestations: [] });
+
+    await runCommand(['-s', '0xschema', '-a', '0xAttester']);
+
+    expect(graphqlQuery).toHaveBeenCalledTimes(1);
+    expect(graphqlQuery).toHaveBeenCalledWith(
+      'ethereum',
+      QUERIES.getAttestationsBySchema,
+      expect.objectContaining({ schemaId: '0xschema' })
+    );
+  });
+
+  it('throws when neither schema nor attester provided', async () => {
+    await runCommand([]);
+
+    expect(handleError).toHaveBeenCalledWith(expect.any(Error));
+    const err = (handleError as any).mock.calls[0][0] as Error;
+    expect(err.message).toContain('Provide at least one filter');
+  });
+
+  it('passes limit as integer', async () => {
+    (graphqlQuery as any).mockResolvedValue({ attestations: [] });
+
+    await runCommand(['-s', '0xschema', '-n', '25']);
+
+    expect(graphqlQuery).toHaveBeenCalledWith(
+      'ethereum',
+      expect.any(String),
+      expect.objectContaining({ take: 25 })
+    );
+  });
+
+  it('parses decodedDataJson for each attestation', async () => {
+    (graphqlQuery as any).mockResolvedValue({
+      attestations: [
+        { id: '0x1', decodedDataJson: '{"key":"value"}' },
+        { id: '0x2', decodedDataJson: null },
+      ],
+    });
+
+    await runCommand(['-s', '0xschema']);
+
+    const outputCall = (output as any).mock.calls[0][0];
+    expect(outputCall.data.attestations[0].decodedData).toEqual({ key: 'value' });
+    expect(outputCall.data.attestations[1].decodedData).toBeUndefined();
+  });
+
+  it('handles invalid decodedDataJson gracefully', async () => {
+    (graphqlQuery as any).mockResolvedValue({
+      attestations: [{ id: '0x1', decodedDataJson: 'bad-json' }],
+    });
+
+    await runCommand(['-s', '0xschema']);
+
+    const outputCall = (output as any).mock.calls[0][0];
+    expect(outputCall.data.attestations[0].decodedData).toBeUndefined();
+  });
+
+  it('returns empty results with count 0', async () => {
+    (graphqlQuery as any).mockResolvedValue({ attestations: [] });
+
+    await runCommand(['-s', '0xschema']);
+
+    expect(output).toHaveBeenCalledWith({
+      success: true,
+      data: { count: 0, attestations: [] },
+    });
+  });
+
+  it('handles missing attestations key in response', async () => {
+    (graphqlQuery as any).mockResolvedValue({});
+
+    await runCommand(['-s', '0xschema']);
+
+    expect(output).toHaveBeenCalledWith({
+      success: true,
+      data: { count: 0, attestations: [] },
+    });
+  });
+});

package/src/__tests__/commands/query-schema.test.ts

@@ -0,0 +1,62 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+vi.mock('../../graphql.js', () => ({
+  graphqlQuery: vi.fn(),
+  QUERIES: {
+    getSchema: 'query GetSchema($id: String!) { schema(where: { id: $id }) { id } }',
+  },
+}));
+
+vi.mock('../../output.js', () => ({
+  output: vi.fn(),
+  handleError: vi.fn(),
+}));
+
+vi.mock('../../validation.js', () => ({
+  validateBytes32: vi.fn(),
+}));
+
+import { querySchemaCommand } from '../../commands/query-schema.js';
+import { graphqlQuery, QUERIES } from '../../graphql.js';
+import { output, handleError } from '../../output.js';
+
+describe('query-schema command', () => {
+  beforeEach(() => vi.clearAllMocks());
+
+  async function runCommand(args: string[]) {
+    await querySchemaCommand.parseAsync(['node', 'test', ...args]);
+  }
+
+  it('queries and returns schema data', async () => {
+    (graphqlQuery as any).mockResolvedValue({
+      schema: { id: '0xschema', schema: 'uint256 score', creator: '0xCreator' },
+    });
+
+    await runCommand(['-u', '0xschema']);
+
+    expect(graphqlQuery).toHaveBeenCalledWith('ethereum', QUERIES.getSchema, { id: '0xschema' });
+    expect(output).toHaveBeenCalledWith({
+      success: true,
+      data: { id: '0xschema', schema: 'uint256 score', creator: '0xCreator' },
+    });
+  });
+
+  it('throws when schema not found', async () => {
+    (graphqlQuery as any).mockResolvedValue({ schema: null });
+
+    await runCommand(['-u', '0xmissing']);
+
+    expect(handleError).toHaveBeenCalledWith(expect.any(Error));
+    const err = (handleError as any).mock.calls[0][0] as Error;
+    expect(err.message).toContain('not found');
+  });
+
+  it('uses specified chain', async () => {
+    (graphqlQuery as any).mockResolvedValue({
+      schema: { id: '0xschema' },
+    });
+
+    await runCommand(['-u', '0xschema', '-c', 'base']);
+    expect(graphqlQuery).toHaveBeenCalledWith('base', QUERIES.getSchema, { id: '0xschema' });
+  });
+});

package/src/__tests__/commands/query-schemas.test.ts

@@ -0,0 +1,110 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+vi.mock('../../graphql.js', () => ({
+  graphqlQuery: vi.fn(),
+  QUERIES: {
+    getSchemata: 'query GetSchemata',
+  },
+}));
+
+vi.mock('../../output.js', () => ({
+  output: vi.fn(),
+  handleError: vi.fn(),
+}));
+
+vi.mock('../../validation.js', () => ({
+  validateAddress: vi.fn(),
+}));
+
+import { querySchemasCommand } from '../../commands/query-schemas.js';
+import { graphqlQuery, QUERIES } from '../../graphql.js';
+import { output } from '../../output.js';
+
+describe('query-schemas command', () => {
+  beforeEach(() => vi.clearAllMocks());
+
+  async function runCommand(args: string[]) {
+    await querySchemasCommand.parseAsync(['node', 'test', ...args]);
+  }
+
+  it('queries schemas by creator with default skip', async () => {
+    (graphqlQuery as any).mockResolvedValue({
+      schemata: [{ id: '0xs1', schema: 'uint256 x' }, { id: '0xs2', schema: 'string y' }],
+    });
+
+    await runCommand(['-a', '0xCreator']);
+
+    expect(graphqlQuery).toHaveBeenCalledWith('ethereum', QUERIES.getSchemata, {
+      creator: '0xCreator',
+      take: 10,
+      skip: 0,
+    });
+    expect(output).toHaveBeenCalledWith({
+      success: true,
+      data: { count: 2, schemas: expect.any(Array) },
+    });
+  });
+
+  it('passes custom limit', async () => {
+    (graphqlQuery as any).mockResolvedValue({ schemata: [] });
+
+    await runCommand(['-a', '0xCreator', '-n', '50']);
+
+    expect(graphqlQuery).toHaveBeenCalledWith(
+      'ethereum',
+      QUERIES.getSchemata,
+      expect.objectContaining({ take: 50 })
+    );
+  });
+
+  it('passes skip for pagination', async () => {
+    (graphqlQuery as any).mockResolvedValue({ schemata: [] });
+
+    await runCommand(['-a', '0xCreator', '--skip', '15']);
+
+    expect(graphqlQuery).toHaveBeenCalledWith(
+      'ethereum',
+      QUERIES.getSchemata,
+      expect.objectContaining({ skip: 15 })
+    );
+  });
+
+  it('returns empty results with count 0', async () => {
+    (graphqlQuery as any).mockResolvedValue({ schemata: [] });
+
+    await runCommand(['-a', '0xCreator']);
+
+    expect(output).toHaveBeenCalledWith({
+      success: true,
+      data: { count: 0, schemas: [] },
+    });
+  });
+
+  it('handles missing schemata key in response', async () => {
+    (graphqlQuery as any).mockResolvedValue({});
+
+    await runCommand(['-a', '0xCreator']);
+
+    expect(output).toHaveBeenCalledWith({
+      success: true,
+      data: { count: 0, schemas: [] },
+    });
+  });
+
+  it('passes GraphQL errors to handleError', async () => {
+    (graphqlQuery as any).mockRejectedValue(new Error('network timeout'));
+    await runCommand(['-a', '0xCreator']);
+    const { handleError } = await import('../../output.js');
+    expect(handleError).toHaveBeenCalledWith(expect.any(Error));
+    const err = (handleError as any).mock.calls[0][0] as Error;
+    expect(err.message).toBe('network timeout');
+  });
+
+  it('uses specified chain', async () => {
+    (graphqlQuery as any).mockResolvedValue({ schemata: [] });
+
+    await runCommand(['-a', '0xCreator', '-c', 'polygon']);
+
+    expect(graphqlQuery).toHaveBeenCalledWith('polygon', QUERIES.getSchemata, expect.any(Object));
+  });
+});