easctl 0.1.0

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

@@ -0,0 +1,86 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+const mockEstimateGas = vi.fn().mockResolvedValue(30000n);
+const mockWait = vi.fn();
+const mockTx = { wait: mockWait, receipt: null as any, estimateGas: mockEstimateGas };
+const mockRevoke = vi.fn().mockResolvedValue(mockTx);
+const mockClient = {
+  eas: { revoke: mockRevoke },
+};
+
+vi.mock('../../client.js', () => ({
+  createEASClient: vi.fn(() => mockClient),
+}));
+
+vi.mock('../../output.js', () => ({
+  output: vi.fn(),
+  handleError: vi.fn(),
+}));
+
+vi.mock('../../validation.js', () => ({
+  validateBytes32: vi.fn(),
+}));
+
+import { revokeCommand } from '../../commands/revoke.js';
+import { output, handleError } from '../../output.js';
+
+describe('revoke command', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockWait.mockImplementation(async () => {
+      mockTx.receipt = { hash: '0xrevokehash' };
+      return undefined;
+    });
+  });
+
+  async function runCommand(args: string[]) {
+    await revokeCommand.parseAsync(['node', 'test', ...args]);
+  }
+
+  it('revokes attestation successfully', async () => {
+    await runCommand(['-s', '0xschema', '-u', '0xuid']);
+
+    expect(mockRevoke).toHaveBeenCalledWith({
+      schema: '0xschema',
+      data: { uid: '0xuid', value: 0n },
+    });
+    expect(output).toHaveBeenCalledWith({
+      success: true,
+      data: {
+        revoked: true,
+        uid: '0xuid',
+        txHash: '0xrevokehash',
+        schema: '0xschema',
+        chain: 'ethereum',
+      },
+    });
+  });
+
+  it('passes SDK errors to handleError', async () => {
+    mockRevoke.mockRejectedValueOnce(new Error('revocation failed'));
+    await runCommand(['-s', '0xschema', '-u', '0xuid']);
+    expect(handleError).toHaveBeenCalledWith(expect.any(Error));
+    const err = (handleError as any).mock.calls[0][0] as Error;
+    expect(err.message).toBe('revocation failed');
+  });
+
+  it('passes custom value as BigInt', async () => {
+    await runCommand(['-s', '0xschema', '-u', '0xuid', '--value', '1000']);
+
+    expect(mockRevoke).toHaveBeenCalledWith({
+      schema: '0xschema',
+      data: { uid: '0xuid', value: 1000n },
+    });
+  });
+
+  it('estimates gas in dry-run mode without sending', async () => {
+    await runCommand(['-s', '0xschema', '-u', '0xuid', '--dry-run']);
+
+    expect(mockEstimateGas).toHaveBeenCalled();
+    expect(mockWait).not.toHaveBeenCalled();
+    expect(output).toHaveBeenCalledWith({
+      success: true,
+      data: { dryRun: true, estimatedGas: '30000', chain: 'ethereum' },
+    });
+  });
+});

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

@@ -0,0 +1,66 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+const mockGetSchema = vi.fn().mockResolvedValue({
+  uid: '0xschemauid',
+  schema: 'uint256 score',
+  resolver: '0x0000000000000000000000000000000000000000',
+  revocable: true,
+});
+const mockClient = {
+  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(),
+}));
+
+import { schemaGetCommand } from '../../commands/schema-get.js';
+import { createReadOnlyEASClient } from '../../client.js';
+import { output } from '../../output.js';
+
+describe('schema-get command', () => {
+  beforeEach(() => vi.clearAllMocks());
+
+  async function runCommand(args: string[]) {
+    await schemaGetCommand.parseAsync(['node', 'test', ...args]);
+  }
+
+  it('gets schema by uid', async () => {
+    await runCommand(['-u', '0xschemauid']);
+
+    expect(createReadOnlyEASClient).toHaveBeenCalledWith('ethereum', undefined);
+    expect(mockGetSchema).toHaveBeenCalledWith({ uid: '0xschemauid' });
+    expect(output).toHaveBeenCalledWith({
+      success: true,
+      data: {
+        uid: '0xschemauid',
+        schema: 'uint256 score',
+        resolver: '0x0000000000000000000000000000000000000000',
+        revocable: true,
+      },
+    });
+  });
+
+  it('passes SDK errors to handleError', async () => {
+    mockGetSchema.mockRejectedValueOnce(new Error('contract not found'));
+    await runCommand(['-u', '0xschemauid']);
+    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('contract not found');
+  });
+
+  it('uses specified chain', async () => {
+    await runCommand(['-u', '0xschemauid', '-c', 'base']);
+    expect(createReadOnlyEASClient).toHaveBeenCalledWith('base', undefined);
+  });
+});

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

@@ -0,0 +1,94 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+const mockEstimateGas = vi.fn().mockResolvedValue(45000n);
+const mockWait = vi.fn();
+const mockTx = { wait: mockWait, receipt: null as any, estimateGas: mockEstimateGas };
+const mockRegister = vi.fn().mockResolvedValue(mockTx);
+const mockClient = {
+  schemaRegistry: { register: mockRegister },
+};
+
+vi.mock('../../client.js', () => ({
+  createEASClient: vi.fn(() => mockClient),
+}));
+
+vi.mock('../../output.js', () => ({
+  output: vi.fn(),
+  handleError: vi.fn(),
+}));
+
+vi.mock('../../validation.js', () => ({
+  validateAddress: vi.fn(),
+}));
+
+import { schemaRegisterCommand } from '../../commands/schema-register.js';
+import { output } from '../../output.js';
+
+describe('schema-register command', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockWait.mockImplementation(async () => {
+      mockTx.receipt = { hash: '0xreghash' };
+      return '0xschemauid';
+    });
+  });
+
+  async function runCommand(args: string[]) {
+    await schemaRegisterCommand.parseAsync(['node', 'test', ...args]);
+  }
+
+  it('registers schema with defaults', async () => {
+    await runCommand(['-s', 'uint256 score, string name']);
+
+    expect(mockRegister).toHaveBeenCalledWith({
+      schema: 'uint256 score, string name',
+      resolverAddress: '0x0000000000000000000000000000000000000000',
+      revocable: true,
+    });
+    expect(output).toHaveBeenCalledWith({
+      success: true,
+      data: {
+        uid: '0xschemauid',
+        txHash: '0xreghash',
+        schema: 'uint256 score, string name',
+        resolver: '0x0000000000000000000000000000000000000000',
+        revocable: true,
+        chain: 'ethereum',
+      },
+    });
+  });
+
+  it('passes custom resolver', async () => {
+    await runCommand(['-s', 'uint8 x', '--resolver', '0xResolver']);
+    expect(mockRegister).toHaveBeenCalledWith(
+      expect.objectContaining({ resolverAddress: '0xResolver' })
+    );
+  });
+
+  it('passes SDK errors to handleError', async () => {
+    mockRegister.mockRejectedValueOnce(new Error('tx reverted'));
+    await runCommand(['-s', 'uint8 x']);
+    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('tx reverted');
+  });
+
+  it('handles --no-revocable', async () => {
+    await runCommand(['-s', 'uint8 x', '--no-revocable']);
+    expect(mockRegister).toHaveBeenCalledWith(
+      expect.objectContaining({ revocable: false })
+    );
+  });
+
+  it('estimates gas in dry-run mode without sending', async () => {
+    await runCommand(['-s', 'uint8 x', '--dry-run']);
+
+    expect(mockEstimateGas).toHaveBeenCalled();
+    expect(mockWait).not.toHaveBeenCalled();
+    expect(output).toHaveBeenCalledWith({
+      success: true,
+      data: { dryRun: true, estimatedGas: '45000', chain: 'ethereum' },
+    });
+  });
+});

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

@@ -0,0 +1,78 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+const mockEstimateGas = vi.fn().mockResolvedValue(25000n);
+const mockWait = vi.fn();
+const mockTx = { wait: mockWait, receipt: null as any, estimateGas: mockEstimateGas };
+const mockTimestamp = vi.fn().mockResolvedValue(mockTx);
+const mockClient = {
+  eas: { timestamp: mockTimestamp },
+};
+
+vi.mock('../../client.js', () => ({
+  createEASClient: vi.fn(() => mockClient),
+}));
+
+vi.mock('../../output.js', () => ({
+  output: vi.fn(),
+  handleError: vi.fn(),
+}));
+
+import { timestampCommand } from '../../commands/timestamp.js';
+import { output } from '../../output.js';
+
+describe('timestamp command', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockWait.mockImplementation(async () => {
+      mockTx.receipt = { hash: '0xtshash' };
+      return 1700000000n;
+    });
+  });
+
+  async function runCommand(args: string[]) {
+    await timestampCommand.parseAsync(['node', 'test', ...args]);
+  }
+
+  it('timestamps data on-chain', async () => {
+    await runCommand(['-d', '0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890']);
+
+    expect(mockTimestamp).toHaveBeenCalledWith(
+      '0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890'
+    );
+    expect(output).toHaveBeenCalledWith({
+      success: true,
+      data: {
+        timestamp: '1700000000',
+        txHash: '0xtshash',
+        data: '0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890',
+        chain: 'ethereum',
+      },
+    });
+  });
+
+  it('passes SDK errors to handleError', async () => {
+    mockTimestamp.mockRejectedValueOnce(new Error('nonce too low'));
+    await runCommand(['-d', '0x1234']);
+    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('nonce too low');
+  });
+
+  it('uses specified chain', async () => {
+    const { createEASClient } = await import('../../client.js');
+    await runCommand(['-d', '0x1234', '-c', 'base']);
+    expect(createEASClient).toHaveBeenCalledWith('base', undefined);
+  });
+
+  it('estimates gas in dry-run mode without sending', async () => {
+    await runCommand(['-d', '0x1234', '--dry-run']);
+
+    expect(mockEstimateGas).toHaveBeenCalled();
+    expect(mockWait).not.toHaveBeenCalled();
+    expect(output).toHaveBeenCalledWith({
+      success: true,
+      data: { dryRun: true, estimatedGas: '25000', chain: 'ethereum' },
+    });
+  });
+});

package/src/__tests__/config.test.ts

@@ -0,0 +1,103 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { readFileSync, writeFileSync } from 'fs';
+import { homedir } from 'os';
+import {
+  getConfigPath,
+  readConfig,
+  getStoredPrivateKey,
+  setStoredPrivateKey,
+  clearStoredPrivateKey,
+} from '../config.js';
+
+vi.mock('fs', () => ({
+  readFileSync: vi.fn(),
+  writeFileSync: vi.fn(),
+}));
+
+vi.mock('os', () => ({
+  homedir: vi.fn(() => '/mock/home'),
+}));
+
+describe('config module', () => {
+  beforeEach(() => vi.clearAllMocks());
+
+  describe('getConfigPath', () => {
+    it('returns ~/.eas-cli', () => {
+      expect(getConfigPath()).toBe('/mock/home/.eas-cli');
+    });
+  });
+
+  describe('readConfig', () => {
+    it('returns parsed config when file exists', () => {
+      vi.mocked(readFileSync).mockReturnValue('{"privateKey":"0xabc"}');
+      expect(readConfig()).toEqual({ privateKey: '0xabc' });
+    });
+
+    it('returns empty object when file does not exist', () => {
+      vi.mocked(readFileSync).mockImplementation(() => { throw new Error('ENOENT'); });
+      expect(readConfig()).toEqual({});
+    });
+
+    it('returns empty object when file contains malformed JSON', () => {
+      vi.mocked(readFileSync).mockReturnValue('not valid json{{{');
+      expect(readConfig()).toEqual({});
+    });
+  });
+
+  describe('getStoredPrivateKey', () => {
+    it('returns the stored key', () => {
+      vi.mocked(readFileSync).mockReturnValue('{"privateKey":"0xdef"}');
+      expect(getStoredPrivateKey()).toBe('0xdef');
+    });
+
+    it('returns undefined when no key is stored', () => {
+      vi.mocked(readFileSync).mockReturnValue('{}');
+      expect(getStoredPrivateKey()).toBeUndefined();
+    });
+  });
+
+  describe('setStoredPrivateKey', () => {
+    it('stores key with 0x prefix', () => {
+      vi.mocked(readFileSync).mockReturnValue('{}');
+      setStoredPrivateKey('0xabc123');
+      expect(writeFileSync).toHaveBeenCalledWith(
+        '/mock/home/.eas-cli',
+        JSON.stringify({ privateKey: '0xabc123' }, null, 2) + '\n',
+        { mode: 0o600 },
+      );
+    });
+
+    it('adds 0x prefix when missing', () => {
+      vi.mocked(readFileSync).mockReturnValue('{}');
+      setStoredPrivateKey('abc123');
+      expect(writeFileSync).toHaveBeenCalledWith(
+        '/mock/home/.eas-cli',
+        JSON.stringify({ privateKey: '0xabc123' }, null, 2) + '\n',
+        { mode: 0o600 },
+      );
+    });
+
+    it('preserves other config fields', () => {
+      vi.mocked(readFileSync).mockReturnValue('{"other":"value"}');
+      setStoredPrivateKey('0xkey');
+      const written = vi.mocked(writeFileSync).mock.calls[0][1] as string;
+      expect(JSON.parse(written)).toEqual({ other: 'value', privateKey: '0xkey' });
+    });
+  });
+
+  describe('clearStoredPrivateKey', () => {
+    it('removes the privateKey field', () => {
+      vi.mocked(readFileSync).mockReturnValue('{"privateKey":"0xabc","other":"value"}');
+      clearStoredPrivateKey();
+      const written = vi.mocked(writeFileSync).mock.calls[0][1] as string;
+      expect(JSON.parse(written)).toEqual({ other: 'value' });
+    });
+
+    it('handles missing key gracefully', () => {
+      vi.mocked(readFileSync).mockReturnValue('{}');
+      clearStoredPrivateKey();
+      const written = vi.mocked(writeFileSync).mock.calls[0][1] as string;
+      expect(JSON.parse(written)).toEqual({});
+    });
+  });
+});

package/src/__tests__/graphql.test.ts

@@ -0,0 +1,148 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { getGraphQLEndpoint, graphqlQuery, QUERIES } from '../graphql.js';
+
+describe('graphql module', () => {
+  describe('getGraphQLEndpoint', () => {
+    it('returns ethereum endpoint', () => {
+      expect(getGraphQLEndpoint('ethereum')).toBe('https://easscan.org/graphql');
+    });
+
+    it('returns sepolia endpoint', () => {
+      expect(getGraphQLEndpoint('sepolia')).toBe('https://sepolia.easscan.org/graphql');
+    });
+
+    it('returns base endpoint', () => {
+      expect(getGraphQLEndpoint('base')).toBe('https://base.easscan.org/graphql');
+    });
+
+    it('throws for unknown chain', () => {
+      expect(() => getGraphQLEndpoint('unknown')).toThrow('No EASScan URL for chain "unknown"');
+    });
+  });
+
+  describe('graphqlQuery', () => {
+    let fetchMock: ReturnType<typeof vi.fn>;
+
+    beforeEach(() => {
+      fetchMock = vi.fn();
+      vi.stubGlobal('fetch', fetchMock);
+    });
+
+    afterEach(() => {
+      vi.unstubAllGlobals();
+    });
+
+    it('sends POST request with correct body', async () => {
+      fetchMock.mockResolvedValue({
+        ok: true,
+        json: async () => ({ data: { schema: { id: '0x123' } } }),
+      });
+
+      await graphqlQuery('ethereum', 'query { schema }', { id: '0x123' });
+
+      expect(fetchMock).toHaveBeenCalledWith('https://easscan.org/graphql', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ query: 'query { schema }', variables: { id: '0x123' } }),
+      });
+    });
+
+    it('returns data on success', async () => {
+      fetchMock.mockResolvedValue({
+        ok: true,
+        json: async () => ({ data: { schema: { id: '0x123' } } }),
+      });
+
+      const result = await graphqlQuery('ethereum', 'query { schema }');
+      expect(result).toEqual({ schema: { id: '0x123' } });
+    });
+
+    it('uses empty object as default variables', async () => {
+      fetchMock.mockResolvedValue({
+        ok: true,
+        json: async () => ({ data: {} }),
+      });
+
+      await graphqlQuery('ethereum', 'query { test }');
+
+      const body = JSON.parse(fetchMock.mock.calls[0][1].body);
+      expect(body.variables).toEqual({});
+    });
+
+    it('throws on HTTP error', async () => {
+      fetchMock.mockResolvedValue({
+        ok: false,
+        status: 500,
+        statusText: 'Internal Server Error',
+      });
+
+      await expect(graphqlQuery('ethereum', 'query { test }')).rejects.toThrow(
+        'GraphQL request failed: 500 Internal Server Error'
+      );
+    });
+
+    it('throws on GraphQL errors', async () => {
+      fetchMock.mockResolvedValue({
+        ok: true,
+        json: async () => ({
+          errors: [{ message: 'Field not found' }],
+        }),
+      });
+
+      await expect(graphqlQuery('ethereum', 'query { test }')).rejects.toThrow(
+        'GraphQL error: Field not found'
+      );
+    });
+
+    it('throws for unknown chain', async () => {
+      await expect(graphqlQuery('unknown', 'query { test }')).rejects.toThrow(
+        'No EASScan URL for chain "unknown"'
+      );
+    });
+  });
+
+  describe('QUERIES', () => {
+    it('getSchema queries the schema root field with required fields', () => {
+      expect(QUERIES.getSchema).toContain('$id: String!');
+      expect(QUERIES.getSchema).toMatch(/schema\s*\(\s*where:/);
+      expect(QUERIES.getSchema).toContain('schema');
+      expect(QUERIES.getSchema).toContain('creator');
+      expect(QUERIES.getSchema).toContain('resolver');
+      expect(QUERIES.getSchema).toContain('revocable');
+    });
+
+    it('getAttestation queries the attestation root field with required fields', () => {
+      expect(QUERIES.getAttestation).toContain('$id: String!');
+      expect(QUERIES.getAttestation).toMatch(/attestation\s*\(\s*where:/);
+      expect(QUERIES.getAttestation).toContain('attester');
+      expect(QUERIES.getAttestation).toContain('recipient');
+      expect(QUERIES.getAttestation).toContain('decodedDataJson');
+      expect(QUERIES.getAttestation).toContain('schemaId');
+      expect(QUERIES.getAttestation).toContain('data');
+      expect(QUERIES.getAttestation).toContain('revoked');
+    });
+
+    it('getAttestationsBySchema queries attestations root field with schema filter', () => {
+      expect(QUERIES.getAttestationsBySchema).toContain('$schemaId: String!');
+      expect(QUERIES.getAttestationsBySchema).toContain('$take: Int');
+      expect(QUERIES.getAttestationsBySchema).toMatch(/attestations\s*\(/);
+      expect(QUERIES.getAttestationsBySchema).toContain('schemaId');
+      expect(QUERIES.getAttestationsBySchema).toContain('decodedDataJson');
+    });
+
+    it('getAttestationsByAttester queries attestations root field with attester filter', () => {
+      expect(QUERIES.getAttestationsByAttester).toContain('$attester: String!');
+      expect(QUERIES.getAttestationsByAttester).toContain('$take: Int');
+      expect(QUERIES.getAttestationsByAttester).toMatch(/attestations\s*\(/);
+      expect(QUERIES.getAttestationsByAttester).toContain('decodedDataJson');
+    });
+
+    it('getSchemata queries schemata root field with creator filter', () => {
+      expect(QUERIES.getSchemata).toContain('$creator: String');
+      expect(QUERIES.getSchemata).toContain('$take: Int');
+      expect(QUERIES.getSchemata).toMatch(/schemata\s*\(/);
+      expect(QUERIES.getSchemata).toContain('schema');
+      expect(QUERIES.getSchemata).toContain('creator');
+    });
+  });
+});

package/src/__tests__/integration/graphql-live.test.ts

@@ -0,0 +1,103 @@
+import { describe, it, expect } from 'vitest';
+import { graphqlQuery, QUERIES } from '../../graphql.js';
+
+/**
+ * Live smoke tests against the real EASScan GraphQL API (Sepolia).
+ * These verify that our query strings and expected response shapes
+ * actually work against the real indexer — something unit tests with
+ * mocked fetch cannot prove.
+ *
+ * These hit the network so they're slower (~1-2s each).
+ */
+describe('GraphQL live queries (sepolia)', () => {
+  const chain = 'sepolia';
+
+  it('getSchemata returns schemas with expected fields', async () => {
+    const data = await graphqlQuery(chain, QUERIES.getSchemata, { take: 2 });
+
+    expect(data.schemata).toBeDefined();
+    expect(data.schemata.length).toBeGreaterThan(0);
+
+    const schema = data.schemata[0];
+    expect(schema).toHaveProperty('id');
+    expect(schema).toHaveProperty('schema');
+    expect(schema).toHaveProperty('creator');
+    expect(schema).toHaveProperty('revocable');
+    expect(schema).toHaveProperty('time');
+  });
+
+  it('getSchema returns a single schema with expected fields', async () => {
+    // First get a schema ID to query
+    const list = await graphqlQuery(chain, QUERIES.getSchemata, { take: 1 });
+    const schemaId = list.schemata[0].id;
+
+    const data = await graphqlQuery(chain, QUERIES.getSchema, { id: schemaId });
+
+    expect(data.schema).toBeDefined();
+    expect(data.schema.id).toBe(schemaId);
+    expect(data.schema).toHaveProperty('schema');
+    expect(data.schema).toHaveProperty('creator');
+    expect(data.schema).toHaveProperty('resolver');
+    expect(data.schema).toHaveProperty('revocable');
+    expect(data.schema).toHaveProperty('txid');
+    expect(data.schema).toHaveProperty('time');
+  });
+
+  it('getAttestationsBySchema returns attestations with expected fields', async () => {
+    // Use a well-known schema that has attestations on sepolia
+    const data = await graphqlQuery(chain, QUERIES.getAttestationsBySchema, {
+      schemaId: '0x0000000000000000000000000000000000000000000000000000000000000000',
+      take: 1,
+    });
+
+    expect(data.attestations).toBeDefined();
+    expect(Array.isArray(data.attestations)).toBe(true);
+    // Zero-schema may or may not have attestations, but the shape should be valid
+  });
+
+  it('getAttestationsByAttester returns attestations array', async () => {
+    const data = await graphqlQuery(chain, QUERIES.getAttestationsByAttester, {
+      attester: '0x0000000000000000000000000000000000000000',
+      take: 1,
+    });
+
+    expect(data.attestations).toBeDefined();
+    expect(Array.isArray(data.attestations)).toBe(true);
+  });
+
+  it('getAttestation returns a single attestation with all expected fields', async () => {
+    // First get a real attestation ID by querying recent attestations by a known schema
+    // We use getSchemata to find a schema, then query its attestations
+    const schemaList = await graphqlQuery(chain, QUERIES.getSchemata, { take: 1 });
+    const schemaId = schemaList.schemata[0].id;
+
+    const attList = await graphqlQuery(chain, QUERIES.getAttestationsBySchema, {
+      schemaId,
+      take: 1,
+    });
+
+    if (attList.attestations.length === 0) {
+      // No attestations for this schema — skip rather than fail
+      return;
+    }
+
+    const attId = attList.attestations[0].id;
+
+    const data = await graphqlQuery(chain, QUERIES.getAttestation, { id: attId });
+
+    expect(data.attestation).toBeDefined();
+    expect(data.attestation.id).toBe(attId);
+    expect(data.attestation).toHaveProperty('attester');
+    expect(data.attestation).toHaveProperty('recipient');
+    expect(data.attestation).toHaveProperty('time');
+    expect(data.attestation).toHaveProperty('expirationTime');
+    expect(data.attestation).toHaveProperty('revocationTime');
+    expect(data.attestation).toHaveProperty('revoked');
+    expect(data.attestation).toHaveProperty('revocable');
+    expect(data.attestation).toHaveProperty('schemaId');
+    expect(data.attestation).toHaveProperty('data');
+    expect(data.attestation).toHaveProperty('decodedDataJson');
+    expect(data.attestation).toHaveProperty('isOffchain');
+    expect(data.attestation).toHaveProperty('txid');
+  });
+});