easctl 0.1.0

package/manual-test/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "manual-test",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "Steve Dakh",
+  "license": "ISC",
+  "dependencies": {
+    "easctl": "^0.1.0"
+  }
+}

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "easctl",
+  "version": "0.1.0",
+  "description": "CLI tool for the Ethereum Attestation Service — create, revoke, and query attestations from the command line",
+  "bin": {
+    "easctl": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "start": "node dist/index.js",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run"
+  },
+  "keywords": [
+    "ethereum",
+    "attestation",
+    "eas",
+    "cli",
+    "ethers",
+    "web3"
+  ],
+  "author": "Ethereum Attestation Service",
+  "license": "MIT",
+  "dependencies": {
+    "@ethereum-attestation-service/eas-sdk": "^2.9.0",
+    "commander": "^13.1.0",
+    "ethers": "^6.16.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "@vitest/coverage-v8": "^4.1.1",
+    "tsup": "^8.4.0",
+    "typescript": "^5.7.0",
+    "vitest": "^4.1.1"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}

package/src/__tests__/chains.test.ts

@@ -0,0 +1,82 @@
+import { describe, it, expect } from 'vitest';
+import { getChainConfig, listChains, CHAIN_CONFIGS } from '../chains.js';
+
+describe('chains module', () => {
+  describe('getChainConfig', () => {
+    it('returns ethereum config', () => {
+      const config = getChainConfig('ethereum');
+      expect(config.chainId).toBe(1);
+      expect(config.eas).toBe('0xA1207F3BBa224E2c9c3c6D5aF63D0eb1582Ce587');
+      expect(config.schemaRegistry).toBe('0xA7b39296258348C78294F95B872b282326A97BDF');
+      expect(config.defaultRpc).toBe('https://ethereum-rpc.publicnode.com');
+    });
+
+    it('returns sepolia config', () => {
+      const config = getChainConfig('sepolia');
+      expect(config.chainId).toBe(11155111);
+    });
+
+    it('returns base config with OP stack addresses', () => {
+      const config = getChainConfig('base');
+      expect(config.chainId).toBe(8453);
+      expect(config.eas).toBe('0x4200000000000000000000000000000000000021');
+      expect(config.schemaRegistry).toBe('0x4200000000000000000000000000000000000020');
+    });
+
+    it('returns optimism config with OP stack addresses', () => {
+      const config = getChainConfig('optimism');
+      expect(config.eas).toBe('0x4200000000000000000000000000000000000021');
+    });
+
+    it('throws for unknown chain', () => {
+      expect(() => getChainConfig('unknown')).toThrow('Unknown chain "unknown"');
+    });
+
+    it('lists available chains in error message', () => {
+      expect(() => getChainConfig('invalid')).toThrow('Available chains:');
+    });
+  });
+
+  describe('listChains', () => {
+    it('returns all chain names', () => {
+      const chains = listChains();
+      expect(chains).toContain('ethereum');
+      expect(chains).toContain('sepolia');
+      expect(chains).toContain('base');
+      expect(chains).toContain('base-sepolia');
+      expect(chains).toContain('optimism');
+      expect(chains).toContain('optimism-sepolia');
+      expect(chains).toContain('arbitrum');
+      expect(chains).toContain('arbitrum-sepolia');
+      expect(chains).toContain('polygon');
+      expect(chains).toContain('scroll');
+      expect(chains).toContain('linea');
+      expect(chains).toContain('celo');
+    });
+
+    it('returns 12 chains', () => {
+      expect(listChains()).toHaveLength(12);
+    });
+  });
+
+  describe('CHAIN_CONFIGS', () => {
+    it('all chains have required fields', () => {
+      for (const [name, config] of Object.entries(CHAIN_CONFIGS)) {
+        expect(config.chainId, `${name} missing chainId`).toBeTypeOf('number');
+        expect(config.eas, `${name} missing eas`).toBeTypeOf('string');
+        expect(config.schemaRegistry, `${name} missing schemaRegistry`).toBeTypeOf('string');
+      }
+    });
+
+    it('all chains have a defaultRpc', () => {
+      for (const [name, config] of Object.entries(CHAIN_CONFIGS)) {
+        expect(config.defaultRpc, `${name} missing defaultRpc`).toBeTypeOf('string');
+      }
+    });
+
+    it('all chain IDs are unique', () => {
+      const ids = Object.values(CHAIN_CONFIGS).map((c) => c.chainId);
+      expect(new Set(ids).size).toBe(ids.length);
+    });
+  });
+});

package/src/__tests__/clear-key.test.ts

@@ -0,0 +1,40 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+vi.mock('../config.js', () => ({
+  clearStoredPrivateKey: vi.fn(),
+  getStoredPrivateKey: vi.fn(),
+}));
+
+vi.mock('../output.js', () => ({
+  output: vi.fn(),
+}));
+
+import { clearKeyCommand } from '../commands/clear-key.js';
+import { clearStoredPrivateKey, getStoredPrivateKey } from '../config.js';
+import { output } from '../output.js';
+
+describe('clear-key command', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('clears the stored key', async () => {
+    vi.mocked(getStoredPrivateKey).mockReturnValue('0xabc');
+    await clearKeyCommand.parseAsync(['node', 'test']);
+    expect(clearStoredPrivateKey).toHaveBeenCalled();
+    expect(output).toHaveBeenCalledWith({
+      success: true,
+      data: { cleared: true },
+    });
+  });
+
+  it('reports when no key is stored', async () => {
+    vi.mocked(getStoredPrivateKey).mockReturnValue(undefined);
+    await clearKeyCommand.parseAsync(['node', 'test']);
+    expect(clearStoredPrivateKey).not.toHaveBeenCalled();
+    expect(output).toHaveBeenCalledWith({
+      success: true,
+      data: { cleared: false, message: 'No private key is currently stored' },
+    });
+  });
+});

package/src/__tests__/client.test.ts

@@ -0,0 +1,168 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+
+const mockProvider = { getNetwork: vi.fn() };
+const mockWallet = { address: '0xTestAddress', provider: mockProvider };
+
+vi.mock('ethers', () => {
+  return {
+    ethers: {
+      JsonRpcProvider: class MockJsonRpcProvider {
+        constructor(...args: any[]) {
+          mockProviderConstructor(...args);
+          return mockProvider as any;
+        }
+      },
+      Wallet: class MockWallet {
+        constructor(...args: any[]) {
+          mockWalletConstructor(...args);
+          return mockWallet as any;
+        }
+      },
+    },
+  };
+});
+
+const mockProviderConstructor = vi.fn();
+const mockWalletConstructor = vi.fn();
+
+vi.mock('@ethereum-attestation-service/eas-sdk', () => ({
+  EAS: class MockEAS {
+    constructor(...args: any[]) { mockEASConstructor(...args); }
+  },
+  SchemaRegistry: class MockSchemaRegistry {
+    constructor(...args: any[]) { mockSchemaRegistryConstructor(...args); }
+  },
+}));
+
+const mockEASConstructor = vi.fn();
+const mockSchemaRegistryConstructor = vi.fn();
+
+import { getPrivateKey, createEASClient, createReadOnlyEASClient } from '../client.js';
+import { getStoredPrivateKey } from '../config.js';
+
+vi.mock('../config.js', () => ({
+  getStoredPrivateKey: vi.fn(),
+}));
+
+describe('client module', () => {
+  const originalEnv = process.env.EAS_PRIVATE_KEY;
+
+  afterEach(() => {
+    if (originalEnv !== undefined) {
+      process.env.EAS_PRIVATE_KEY = originalEnv;
+    } else {
+      delete process.env.EAS_PRIVATE_KEY;
+    }
+  });
+
+  describe('getPrivateKey', () => {
+    it('returns key with 0x prefix when already present', () => {
+      process.env.EAS_PRIVATE_KEY = '0xabc123';
+      expect(getPrivateKey()).toBe('0xabc123');
+    });
+
+    it('adds 0x prefix when missing', () => {
+      process.env.EAS_PRIVATE_KEY = 'abc123';
+      expect(getPrivateKey()).toBe('0xabc123');
+    });
+
+    it('throws when env var is not set', () => {
+      delete process.env.EAS_PRIVATE_KEY;
+      expect(() => getPrivateKey()).toThrow('No private key found');
+    });
+
+    it('throws when env var is empty string', () => {
+      process.env.EAS_PRIVATE_KEY = '';
+      expect(() => getPrivateKey()).toThrow('No private key found');
+    });
+
+    it('falls back to stored key when env var not set', () => {
+      delete process.env.EAS_PRIVATE_KEY;
+      vi.mocked(getStoredPrivateKey).mockReturnValue('0xstoredkey');
+      expect(getPrivateKey()).toBe('0xstoredkey');
+    });
+
+    it('env var takes priority over stored key', () => {
+      process.env.EAS_PRIVATE_KEY = '0xenvkey';
+      vi.mocked(getStoredPrivateKey).mockReturnValue('0xstoredkey');
+      expect(getPrivateKey()).toBe('0xenvkey');
+    });
+
+    it('throws when both env var and stored key are missing', () => {
+      delete process.env.EAS_PRIVATE_KEY;
+      vi.mocked(getStoredPrivateKey).mockReturnValue(undefined);
+      expect(() => getPrivateKey()).toThrow('No private key found');
+    });
+  });
+
+  describe('createEASClient', () => {
+    beforeEach(() => {
+      process.env.EAS_PRIVATE_KEY = '0xdeadbeef';
+      vi.clearAllMocks();
+    });
+
+    it('creates client with custom rpcUrl', () => {
+      createEASClient('ethereum', 'https://custom-rpc.com');
+      expect(mockProviderConstructor).toHaveBeenCalledWith('https://custom-rpc.com');
+    });
+
+    it('falls back to default chain RPC when no rpcUrl', () => {
+      createEASClient('ethereum');
+      expect(mockProviderConstructor).toHaveBeenCalledWith('https://ethereum-rpc.publicnode.com');
+    });
+
+    it('creates EAS with correct contract address and signer', () => {
+      createEASClient('ethereum');
+      expect(mockEASConstructor).toHaveBeenCalledWith(
+        '0xA1207F3BBa224E2c9c3c6D5aF63D0eb1582Ce587',
+        { signer: mockWallet }
+      );
+    });
+
+    it('creates SchemaRegistry with correct contract address and signer', () => {
+      createEASClient('ethereum');
+      expect(mockSchemaRegistryConstructor).toHaveBeenCalledWith(
+        '0xA7b39296258348C78294F95B872b282326A97BDF',
+        { signer: mockWallet }
+      );
+    });
+
+    it('returns client with address', () => {
+      const client = createEASClient('ethereum');
+      expect(client.address).toBe('0xTestAddress');
+    });
+
+    it('throws for unknown chain', () => {
+      expect(() => createEASClient('unknown')).toThrow('Unknown chain "unknown"');
+    });
+  });
+
+  describe('createReadOnlyEASClient', () => {
+    beforeEach(() => vi.clearAllMocks());
+
+    it('creates read-only client without wallet, passes provider as signer', () => {
+      const client = createReadOnlyEASClient('sepolia');
+      expect(mockWalletConstructor).not.toHaveBeenCalled();
+      expect(client.provider).toBeDefined();
+      // Verify EAS and SchemaRegistry receive the provider as signer (not a Wallet)
+      expect(mockEASConstructor).toHaveBeenCalledWith(
+        expect.any(String),
+        { signer: mockProvider }
+      );
+      expect(mockSchemaRegistryConstructor).toHaveBeenCalledWith(
+        expect.any(String),
+        { signer: mockProvider }
+      );
+    });
+
+    it('uses default RPC when no custom URL', () => {
+      createReadOnlyEASClient('sepolia');
+      expect(mockProviderConstructor).toHaveBeenCalledWith('https://ethereum-sepolia-rpc.publicnode.com');
+    });
+
+    it('uses custom RPC when provided', () => {
+      createReadOnlyEASClient('sepolia', 'https://my-rpc.com');
+      expect(mockProviderConstructor).toHaveBeenCalledWith('https://my-rpc.com');
+    });
+  });
+});

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

@@ -0,0 +1,203 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+const mockEstimateGas = vi.fn().mockResolvedValue(21000n);
+const mockWait = vi.fn();
+const mockTx = { wait: mockWait, receipt: null as any, estimateGas: mockEstimateGas };
+const mockAttest = vi.fn().mockResolvedValue(mockTx);
+const mockClient = {
+  eas: { attest: mockAttest },
+  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(),
+}));
+
+const mockEncodeData = vi.fn().mockReturnValue('0xencoded');
+
+vi.mock('@ethereum-attestation-service/eas-sdk', () => ({
+  SchemaEncoder: class MockSchemaEncoder {
+    constructor(...args: any[]) { mockSchemaEncoderConstructor(...args); }
+    encodeData = mockEncodeData;
+  },
+  NO_EXPIRATION: 0n,
+  ZERO_BYTES32: '0x0000000000000000000000000000000000000000000000000000000000000000',
+}));
+
+const mockSchemaEncoderConstructor = vi.fn();
+
+import { attestCommand } from '../../commands/attest.js';
+import { createEASClient } from '../../client.js';
+import { output, handleError } from '../../output.js';
+import { resolveInput } from '../../stdin.js';
+
+describe('attest command', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockWait.mockImplementation(async () => {
+      mockTx.receipt = { hash: '0xtxhash123' };
+      return '0xuid123';
+    });
+  });
+
+  async function runCommand(args: string[]) {
+    await attestCommand.parseAsync(['node', 'test', ...args]);
+  }
+
+  it('creates attestation with valid data', async () => {
+    await runCommand([
+      '-s', '0xschema',
+      '-d', '[{"name":"score","type":"uint256","value":"100"}]',
+    ]);
+
+    expect(createEASClient).toHaveBeenCalledWith('ethereum', undefined);
+    expect(resolveInput).toHaveBeenCalledWith('[{"name":"score","type":"uint256","value":"100"}]');
+    expect(mockSchemaEncoderConstructor).toHaveBeenCalledWith('uint256 score');
+    expect(mockEncodeData).toHaveBeenCalledWith([
+      { name: 'score', type: 'uint256', value: '100' },
+    ]);
+    expect(mockAttest).toHaveBeenCalledWith({
+      schema: '0xschema',
+      data: expect.objectContaining({
+        recipient: '0x0000000000000000000000000000000000000000',
+        revocable: true,
+        data: '0xencoded',
+      }),
+    });
+    expect(output).toHaveBeenCalledWith({
+      success: true,
+      data: expect.objectContaining({
+        uid: '0xuid123',
+        txHash: '0xtxhash123',
+        attester: '0xAttester',
+        schema: '0xschema',
+        chain: 'ethereum',
+      }),
+    });
+  });
+
+  it('handles invalid JSON in --data', async () => {
+    await runCommand(['-s', '0xschema', '-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('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 custom recipient', async () => {
+    await runCommand([
+      '-s', '0xschema',
+      '-d', '[{"name":"x","type":"uint8","value":"1"}]',
+      '-r', '0xRecipient',
+    ]);
+    expect(mockAttest).toHaveBeenCalledWith(
+      expect.objectContaining({
+        data: expect.objectContaining({ recipient: '0xRecipient' }),
+      })
+    );
+  });
+
+  it('passes value as BigInt', async () => {
+    await runCommand([
+      '-s', '0xschema',
+      '-d', '[{"name":"x","type":"uint8","value":"1"}]',
+      '--value', '1000',
+    ]);
+    expect(mockAttest).toHaveBeenCalledWith(
+      expect.objectContaining({
+        data: expect.objectContaining({ value: 1000n }),
+      })
+    );
+  });
+
+  it('uses NO_EXPIRATION constant when expiration is 0', async () => {
+    await runCommand([
+      '-s', '0xschema',
+      '-d', '[{"name":"x","type":"uint8","value":"1"}]',
+      '--expiration', '0',
+    ]);
+    const callData = mockAttest.mock.calls[0][0].data;
+    expect(callData.expirationTime).toBe(0n);
+  });
+
+  it('passes non-zero expiration as BigInt (not NO_EXPIRATION)', async () => {
+    await runCommand([
+      '-s', '0xschema',
+      '-d', '[{"name":"x","type":"uint8","value":"1"}]',
+      '--expiration', '1700000000',
+    ]);
+    const callData = mockAttest.mock.calls[0][0].data;
+    expect(callData.expirationTime).toBe(1700000000n);
+    expect(callData.expirationTime).not.toBe(0n);
+  });
+
+  it('passes --no-revocable as false', async () => {
+    await runCommand([
+      '-s', '0xschema',
+      '-d', '[{"name":"x","type":"uint8","value":"1"}]',
+      '--no-revocable',
+    ]);
+    expect(mockAttest).toHaveBeenCalledWith(
+      expect.objectContaining({
+        data: expect.objectContaining({ revocable: false }),
+      })
+    );
+  });
+
+  it('passes SDK errors to handleError', async () => {
+    mockAttest.mockRejectedValueOnce(new Error('insufficient funds'));
+    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('insufficient funds');
+  });
+
+  it('builds schema string from multiple data items', async () => {
+    await runCommand([
+      '-s', '0xschema',
+      '-d', '[{"name":"score","type":"uint256","value":"1"},{"name":"name","type":"string","value":"test"}]',
+    ]);
+    expect(mockSchemaEncoderConstructor).toHaveBeenCalledWith('uint256 score, string name');
+  });
+
+  it('estimates gas in dry-run mode without sending', async () => {
+    await runCommand([
+      '-s', '0xschema',
+      '-d', '[{"name":"x","type":"uint8","value":"1"}]',
+      '--dry-run',
+    ]);
+
+    expect(mockEstimateGas).toHaveBeenCalled();
+    expect(mockWait).not.toHaveBeenCalled();
+    expect(output).toHaveBeenCalledWith({
+      success: true,
+      data: { dryRun: true, estimatedGas: '21000', chain: 'ethereum' },
+    });
+  });
+});