easctl 0.1.0

package/src/__tests__/integration/offchain-signing.test.ts

@@ -0,0 +1,252 @@
+import { describe, it, expect, beforeAll } from 'vitest';
+import { ethers } from 'ethers';
+import {
+  SchemaEncoder,
+  Offchain,
+  OffchainAttestationVersion,
+  createOffchainURL,
+  NO_EXPIRATION,
+  ZERO_BYTES32,
+  EAS,
+} from '@ethereum-attestation-service/eas-sdk';
+
+// Use a deterministic test private key (not a real key - for testing only)
+const TEST_PRIVATE_KEY = '0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80';
+
+describe('off-chain attestation signing integration', () => {
+  let signer: ethers.Wallet;
+  let offchain: Offchain;
+  const EAS_CONTRACT_ADDRESS = '0xA1207F3BBa224E2c9c3c6D5aF63D0eb1582Ce587';
+
+  beforeAll(() => {
+    signer = new ethers.Wallet(TEST_PRIVATE_KEY);
+
+    // Create Offchain instance directly with test config (no network needed)
+    offchain = new Offchain(
+      {
+        address: EAS_CONTRACT_ADDRESS,
+        version: '1.3.0',
+        chainId: 1n,
+      },
+      OffchainAttestationVersion.Version2,
+      new EAS(EAS_CONTRACT_ADDRESS)
+    );
+  });
+
+  it('signs and verifies an off-chain attestation', async () => {
+    const schemaEncoder = new SchemaEncoder('uint256 score, string name');
+    const encodedData = schemaEncoder.encodeData([
+      { name: 'score', type: 'uint256', value: 100 },
+      { name: 'name', type: 'string', value: 'Alice' },
+    ]);
+
+    const schemaUID = '0x' + 'ab'.repeat(32);
+
+    const signedAttestation = await offchain.signOffchainAttestation(
+      {
+        schema: schemaUID,
+        recipient: '0x0000000000000000000000000000000000000001',
+        time: BigInt(Math.floor(Date.now() / 1000)),
+        expirationTime: NO_EXPIRATION,
+        revocable: true,
+        refUID: ZERO_BYTES32,
+        data: encodedData,
+      },
+      signer
+    );
+
+    // Verify the attestation has expected fields
+    expect(signedAttestation.uid).toMatch(/^0x[0-9a-fA-F]{64}$/);
+    expect(signedAttestation.message).toBeDefined();
+    expect(signedAttestation.signature).toBeDefined();
+    expect(signedAttestation.message.schema).toBe(schemaUID);
+    expect(signedAttestation.message.recipient).toBe('0x0000000000000000000000000000000000000001');
+    expect(signedAttestation.message.revocable).toBe(true);
+
+    // Verify the signature is valid
+    const isValid = offchain.verifyOffchainAttestationSignature(
+      signer.address,
+      signedAttestation
+    );
+    expect(isValid).toBe(true);
+  });
+
+  it('rejects tampered attestation data', async () => {
+    const schemaEncoder = new SchemaEncoder('string msg');
+    const encodedData = schemaEncoder.encodeData([
+      { name: 'msg', type: 'string', value: 'original' },
+    ]);
+
+    const signed = await offchain.signOffchainAttestation(
+      {
+        schema: '0x' + '00'.repeat(32),
+        recipient: '0x0000000000000000000000000000000000000000',
+        time: BigInt(Math.floor(Date.now() / 1000)),
+        expirationTime: NO_EXPIRATION,
+        revocable: true,
+        refUID: ZERO_BYTES32,
+        data: encodedData,
+      },
+      signer
+    );
+
+    // Tamper with the message recipient
+    const tampered = {
+      ...signed,
+      message: { ...signed.message, recipient: '0x0000000000000000000000000000000000000099' },
+    };
+
+    // Tampered data should fail verification against the real signer
+    const isTamperedValid = offchain.verifyOffchainAttestationSignature(
+      signer.address,
+      tampered
+    );
+    expect(isTamperedValid).toBe(false);
+
+    // Wrong attester on untampered data should also fail
+    const isWrongAttesterValid = offchain.verifyOffchainAttestationSignature(
+      '0x0000000000000000000000000000000000000099',
+      signed
+    );
+    expect(isWrongAttesterValid).toBe(false);
+  });
+
+  it('different signers produce different signatures', async () => {
+    const signer2 = new ethers.Wallet(
+      '0x59c6995e998f97a5a0044966f0945389dc9e86dae88c7a8412f4603b6b78690d'
+    );
+
+    const schemaEncoder = new SchemaEncoder('uint8 x');
+    const encodedData = schemaEncoder.encodeData([{ name: 'x', type: 'uint8', value: 1 }]);
+
+    const params = {
+      schema: '0x' + '11'.repeat(32),
+      recipient: '0x0000000000000000000000000000000000000000',
+      time: 1700000000n,
+      expirationTime: NO_EXPIRATION,
+      revocable: true,
+      refUID: ZERO_BYTES32,
+      data: encodedData,
+    };
+
+    const signed1 = await offchain.signOffchainAttestation(params, signer);
+    const signed2 = await offchain.signOffchainAttestation(params, signer2);
+
+    // Different signers produce different signatures
+    expect(signed1.signature).not.toEqual(signed2.signature);
+
+    // Each verifies with its own signer
+    expect(offchain.verifyOffchainAttestationSignature(signer.address, signed1)).toBe(true);
+    expect(offchain.verifyOffchainAttestationSignature(signer2.address, signed2)).toBe(true);
+
+    // Cross-verification fails
+    expect(offchain.verifyOffchainAttestationSignature(signer.address, signed2)).toBe(false);
+    expect(offchain.verifyOffchainAttestationSignature(signer2.address, signed1)).toBe(false);
+  });
+
+  it('non-revocable attestation signs correctly', async () => {
+    const schemaEncoder = new SchemaEncoder('uint8 x');
+    const encodedData = schemaEncoder.encodeData([{ name: 'x', type: 'uint8', value: 1 }]);
+
+    const signed = await offchain.signOffchainAttestation(
+      {
+        schema: '0x' + '22'.repeat(32),
+        recipient: '0x0000000000000000000000000000000000000000',
+        time: 1700000000n,
+        expirationTime: NO_EXPIRATION,
+        revocable: false,
+        refUID: ZERO_BYTES32,
+        data: encodedData,
+      },
+      signer
+    );
+
+    expect(signed.message.revocable).toBe(false);
+    expect(offchain.verifyOffchainAttestationSignature(signer.address, signed)).toBe(true);
+  });
+
+  it('attestation with expiration signs correctly', async () => {
+    const schemaEncoder = new SchemaEncoder('uint8 x');
+    const encodedData = schemaEncoder.encodeData([{ name: 'x', type: 'uint8', value: 1 }]);
+
+    const expiration = BigInt(Math.floor(Date.now() / 1000) + 86400); // +1 day
+
+    const signed = await offchain.signOffchainAttestation(
+      {
+        schema: '0x' + '33'.repeat(32),
+        recipient: '0x0000000000000000000000000000000000000000',
+        time: 1700000000n,
+        expirationTime: expiration,
+        revocable: true,
+        refUID: ZERO_BYTES32,
+        data: encodedData,
+      },
+      signer
+    );
+
+    expect(signed.message.expirationTime).toBe(expiration);
+    expect(offchain.verifyOffchainAttestationSignature(signer.address, signed)).toBe(true);
+  });
+});
+
+describe('createOffchainURL integration', () => {
+  it('produces a URL path from a signed attestation package', async () => {
+    const signer = new ethers.Wallet(TEST_PRIVATE_KEY);
+    const offchain = new Offchain(
+      { address: '0xA1207F3BBa224E2c9c3c6D5aF63D0eb1582Ce587', version: '1.3.0', chainId: 1n },
+      OffchainAttestationVersion.Version2,
+      new EAS('0xA1207F3BBa224E2c9c3c6D5aF63D0eb1582Ce587')
+    );
+
+    const encoder = new SchemaEncoder('uint8 x');
+    const data = encoder.encodeData([{ name: 'x', type: 'uint8', value: 1 }]);
+
+    const signed = await offchain.signOffchainAttestation(
+      {
+        schema: '0x' + '00'.repeat(32),
+        recipient: '0x0000000000000000000000000000000000000000',
+        time: 1700000000n,
+        expirationTime: NO_EXPIRATION,
+        revocable: true,
+        refUID: ZERO_BYTES32,
+        data,
+      },
+      signer
+    );
+
+    const pkg = { sig: signed, signer: signer.address };
+    const urlPath = createOffchainURL(pkg);
+
+    expect(urlPath).toContain('/offchain/url/#attestation=');
+    expect(urlPath.length).toBeGreaterThan(50);
+  });
+
+  it('produces deterministic URLs for same input', async () => {
+    const signer = new ethers.Wallet(TEST_PRIVATE_KEY);
+    const offchain = new Offchain(
+      { address: '0xA1207F3BBa224E2c9c3c6D5aF63D0eb1582Ce587', version: '1.3.0', chainId: 1n },
+      OffchainAttestationVersion.Version2,
+      new EAS('0xA1207F3BBa224E2c9c3c6D5aF63D0eb1582Ce587')
+    );
+
+    const encoder = new SchemaEncoder('string msg');
+    const data = encoder.encodeData([{ name: 'msg', type: 'string', value: 'test' }]);
+
+    const params = {
+      schema: '0x' + 'ff'.repeat(32),
+      recipient: '0x0000000000000000000000000000000000000001',
+      time: 1700000000n,
+      expirationTime: NO_EXPIRATION,
+      revocable: true,
+      refUID: ZERO_BYTES32,
+      data,
+    };
+
+    const signed = await offchain.signOffchainAttestation(params, signer);
+    const pkg = { sig: signed, signer: signer.address };
+
+    const url1 = createOffchainURL(pkg);
+    const url2 = createOffchainURL(pkg);
+    expect(url1).toBe(url2);
+  });
+});

package/src/__tests__/integration/schema-encoder.test.ts

@@ -0,0 +1,131 @@
+import { describe, it, expect } from 'vitest';
+import { SchemaEncoder } from '@ethereum-attestation-service/eas-sdk';
+
+describe('SchemaEncoder integration', () => {
+  describe('encode/decode round-trip', () => {
+    it('handles uint256', () => {
+      const encoder = new SchemaEncoder('uint256 score');
+      const encoded = encoder.encodeData([{ name: 'score', type: 'uint256', value: 42 }]);
+      const decoded = encoder.decodeData(encoded);
+
+      expect(decoded).toHaveLength(1);
+      expect(decoded[0].name).toBe('score');
+      expect(decoded[0].type).toBe('uint256');
+      expect(decoded[0].value.value).toBe(42n);
+    });
+
+    it('handles string', () => {
+      const encoder = new SchemaEncoder('string name');
+      const encoded = encoder.encodeData([{ name: 'name', type: 'string', value: 'hello world' }]);
+      const decoded = encoder.decodeData(encoded);
+
+      expect(decoded[0].value.value).toBe('hello world');
+    });
+
+    it('handles bool', () => {
+      const encoder = new SchemaEncoder('bool active');
+      const encoded = encoder.encodeData([{ name: 'active', type: 'bool', value: true }]);
+      const decoded = encoder.decodeData(encoded);
+
+      expect(decoded[0].value.value).toBe(true);
+    });
+
+    it('handles address', () => {
+      const addr = '0x0000000000000000000000000000000000000001';
+      const encoder = new SchemaEncoder('address wallet');
+      const encoded = encoder.encodeData([{ name: 'wallet', type: 'address', value: addr }]);
+      const decoded = encoder.decodeData(encoded);
+
+      expect(decoded[0].value.value).toBe(addr);
+    });
+
+    it('handles bytes32', () => {
+      const hash = '0x' + 'ab'.repeat(32);
+      const encoder = new SchemaEncoder('bytes32 hash');
+      const encoded = encoder.encodeData([{ name: 'hash', type: 'bytes32', value: hash }]);
+      const decoded = encoder.decodeData(encoded);
+
+      expect(decoded[0].value.value).toBe(hash);
+    });
+
+    it('handles multiple fields', () => {
+      const encoder = new SchemaEncoder('uint256 score, string name, bool active');
+      const encoded = encoder.encodeData([
+        { name: 'score', type: 'uint256', value: 100 },
+        { name: 'name', type: 'string', value: 'Alice' },
+        { name: 'active', type: 'bool', value: false },
+      ]);
+      const decoded = encoder.decodeData(encoded);
+
+      expect(decoded).toHaveLength(3);
+      expect(decoded[0].value.value).toBe(100n);
+      expect(decoded[1].value.value).toBe('Alice');
+      expect(decoded[2].value.value).toBe(false);
+    });
+
+    it('handles large BigInt values', () => {
+      const encoder = new SchemaEncoder('uint256 amount');
+      const bigVal = 2n ** 128n - 1n;
+      const encoded = encoder.encodeData([{ name: 'amount', type: 'uint256', value: bigVal }]);
+      const decoded = encoder.decodeData(encoded);
+
+      expect(decoded[0].value.value).toBe(bigVal);
+    });
+
+    it('handles zero values', () => {
+      const encoder = new SchemaEncoder('uint256 val');
+      const encoded = encoder.encodeData([{ name: 'val', type: 'uint256', value: 0 }]);
+      const decoded = encoder.decodeData(encoded);
+
+      expect(decoded[0].value.value).toBe(0n);
+    });
+
+    it('handles empty string', () => {
+      const encoder = new SchemaEncoder('string text');
+      const encoded = encoder.encodeData([{ name: 'text', type: 'string', value: '' }]);
+      const decoded = encoder.decodeData(encoded);
+
+      expect(decoded[0].value.value).toBe('');
+    });
+
+    it('handles bytes (dynamic)', () => {
+      const encoder = new SchemaEncoder('bytes data');
+      const encoded = encoder.encodeData([{ name: 'data', type: 'bytes', value: '0xdeadbeef' }]);
+      const decoded = encoder.decodeData(encoded);
+
+      expect(decoded[0].value.value).toBe('0xdeadbeef');
+    });
+  });
+
+  describe('schema validation', () => {
+    it('throws on invalid schema type', () => {
+      expect(() => new SchemaEncoder('invalidtype foo')).toThrow();
+    });
+
+    it('throws on mismatched field count in encodeData', () => {
+      const encoder = new SchemaEncoder('uint256 a, string b');
+      expect(() =>
+        encoder.encodeData([{ name: 'a', type: 'uint256', value: 1 }])
+      ).toThrow();
+    });
+  });
+
+  describe('encoded output format', () => {
+    it('produces a hex string', () => {
+      const encoder = new SchemaEncoder('uint256 x');
+      const encoded = encoder.encodeData([{ name: 'x', type: 'uint256', value: 1 }]);
+      expect(encoded).toMatch(/^0x[0-9a-fA-F]+$/);
+    });
+
+    it('produces deterministic encoding', () => {
+      const encoder = new SchemaEncoder('uint256 x, string y');
+      const data = [
+        { name: 'x', type: 'uint256', value: 42 },
+        { name: 'y', type: 'string', value: 'test' },
+      ];
+      const encoded1 = encoder.encodeData(data);
+      const encoded2 = encoder.encodeData(data);
+      expect(encoded1).toBe(encoded2);
+    });
+  });
+});

package/src/__tests__/output.test.ts

@@ -0,0 +1,138 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { setJsonMode, isJsonMode, output, handleError } from '../output.js';
+
+describe('output module', () => {
+  let logSpy: ReturnType<typeof vi.spyOn>;
+  let errorSpy: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(() => {
+    logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    setJsonMode(false);
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe('setJsonMode / isJsonMode', () => {
+    it('defaults to false', () => {
+      expect(isJsonMode()).toBe(false);
+    });
+
+    it('sets to true', () => {
+      setJsonMode(true);
+      expect(isJsonMode()).toBe(true);
+    });
+
+    it('toggles back to false', () => {
+      setJsonMode(true);
+      setJsonMode(false);
+      expect(isJsonMode()).toBe(false);
+    });
+  });
+
+  describe('output() in JSON mode', () => {
+    beforeEach(() => setJsonMode(true));
+
+    it('outputs JSON for success result', () => {
+      output({ success: true, data: { uid: 'abc' } });
+      expect(logSpy).toHaveBeenCalledOnce();
+      const parsed = JSON.parse(logSpy.mock.calls[0][0]);
+      expect(parsed).toEqual({ success: true, data: { uid: 'abc' } });
+    });
+
+    it('serializes BigInt values as strings', () => {
+      output({ success: true, data: { value: BigInt(123) as any } });
+      const parsed = JSON.parse(logSpy.mock.calls[0][0]);
+      expect(parsed.data.value).toBe('123');
+    });
+
+    it('outputs JSON for error result', () => {
+      output({ success: false, error: 'something failed' });
+      const parsed = JSON.parse(logSpy.mock.calls[0][0]);
+      expect(parsed).toEqual({ success: false, error: 'something failed' });
+    });
+  });
+
+  describe('output() in text mode', () => {
+    it('prints key-value pairs for success with data', () => {
+      output({ success: true, data: { uid: 'abc', chain: 'ethereum' } });
+      expect(logSpy).toHaveBeenCalledWith('uid: abc');
+      expect(logSpy).toHaveBeenCalledWith('chain: ethereum');
+    });
+
+    it('prints nested objects with indentation', () => {
+      output({ success: true, data: { info: { name: 'test', value: '42' } } });
+      expect(logSpy).toHaveBeenCalledWith('info:');
+      expect(logSpy).toHaveBeenCalledWith('  name: test');
+      expect(logSpy).toHaveBeenCalledWith('  value: 42');
+    });
+
+    it('formats BigInt values as strings in text mode', () => {
+      output({ success: true, data: { amount: BigInt(999) as any } });
+      expect(logSpy).toHaveBeenCalledWith('amount: 999');
+    });
+
+    it('formats array values through nested object path', () => {
+      output({ success: true, data: { items: [1, 2, 3] as any } });
+      // Arrays are objects, so they go through the nested object path
+      expect(logSpy).toHaveBeenCalledWith('items:');
+      expect(logSpy).toHaveBeenCalledWith('  0: 1');
+      expect(logSpy).toHaveBeenCalledWith('  1: 2');
+      expect(logSpy).toHaveBeenCalledWith('  2: 3');
+    });
+
+    it('prints error to stderr', () => {
+      output({ success: false, error: 'bad thing happened' });
+      expect(errorSpy).toHaveBeenCalledWith('Error: bad thing happened');
+      expect(logSpy).not.toHaveBeenCalled();
+    });
+
+    it('does nothing for success with no data', () => {
+      output({ success: true });
+      expect(logSpy).not.toHaveBeenCalled();
+      expect(errorSpy).not.toHaveBeenCalled();
+    });
+
+    it('does nothing for success false with no error', () => {
+      output({ success: false });
+      expect(logSpy).not.toHaveBeenCalled();
+      expect(errorSpy).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('handleError', () => {
+    let exitSpy: ReturnType<typeof vi.spyOn>;
+
+    beforeEach(() => {
+      exitSpy = vi.spyOn(process, 'exit').mockImplementation(() => undefined as never);
+    });
+
+    it('extracts message from Error instance', () => {
+      handleError(new Error('test error'));
+      expect(errorSpy).toHaveBeenCalledWith('Error: test error');
+      expect(exitSpy).toHaveBeenCalledWith(1);
+    });
+
+    it('converts non-Error to string', () => {
+      handleError('string error');
+      expect(errorSpy).toHaveBeenCalledWith('Error: string error');
+      expect(exitSpy).toHaveBeenCalledWith(1);
+    });
+
+    it('converts number to string', () => {
+      handleError(42);
+      expect(errorSpy).toHaveBeenCalledWith('Error: 42');
+      expect(exitSpy).toHaveBeenCalledWith(1);
+    });
+
+    it('outputs JSON error in JSON mode', () => {
+      setJsonMode(true);
+      handleError(new Error('json error'));
+      const parsed = JSON.parse(logSpy.mock.calls[0][0]);
+      expect(parsed).toEqual({ success: false, error: 'json error' });
+      expect(exitSpy).toHaveBeenCalledWith(1);
+    });
+  });
+});

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

@@ -0,0 +1,58 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+vi.mock('../config.js', () => ({
+  setStoredPrivateKey: vi.fn(),
+}));
+
+vi.mock('../output.js', () => ({
+  output: vi.fn(),
+  handleError: vi.fn(),
+}));
+
+const mockWalletAddress = '0xMockWalletAddress';
+vi.mock('ethers', () => ({
+  ethers: {
+    Wallet: class MockWallet {
+      address = mockWalletAddress;
+      constructor(key: string) {
+        if (key === '0xinvalid') throw new Error('invalid private key');
+      }
+    },
+  },
+}));
+
+import { setKeyCommand } from '../commands/set-key.js';
+import { setStoredPrivateKey } from '../config.js';
+import { output, handleError } from '../output.js';
+
+describe('set-key command', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('stores key and outputs wallet address', async () => {
+    await setKeyCommand.parseAsync(['node', 'test', '0xabc123']);
+    expect(setStoredPrivateKey).toHaveBeenCalledWith('0xabc123');
+    expect(output).toHaveBeenCalledWith({
+      success: true,
+      data: { address: mockWalletAddress },
+    });
+  });
+
+  it('rejects invalid key', async () => {
+    await setKeyCommand.parseAsync(['node', 'test', 'invalid']);
+    expect(handleError).toHaveBeenCalledWith(expect.any(Error));
+    const err = (handleError as any).mock.calls[0][0] as Error;
+    expect(err.message).toBe('Invalid private key format');
+  });
+
+  it('normalizes key without 0x prefix', async () => {
+    await setKeyCommand.parseAsync(['node', 'test', 'abc123']);
+    expect(setStoredPrivateKey).toHaveBeenCalledWith('abc123');
+  });
+
+  it('handles key with 0x prefix', async () => {
+    await setKeyCommand.parseAsync(['node', 'test', '0xabc123']);
+    expect(setStoredPrivateKey).toHaveBeenCalledWith('0xabc123');
+  });
+});

package/src/__tests__/stdin.test.ts

@@ -0,0 +1,15 @@
+import { describe, it, expect } from 'vitest';
+import { resolveInput } from '../stdin.js';
+
+describe('resolveInput', () => {
+  it('returns value as-is when not "-"', async () => {
+    const result = await resolveInput('some data');
+    expect(result).toBe('some data');
+  });
+
+  it('returns JSON string as-is when not "-"', async () => {
+    const json = '[{"name":"score","type":"uint256","value":"100"}]';
+    const result = await resolveInput(json);
+    expect(result).toBe(json);
+  });
+});

package/src/chains.ts

@@ -0,0 +1,99 @@
+export interface ChainConfig {
+  chainId: number;
+  eas: string;
+  schemaRegistry: string;
+  defaultRpc?: string;
+}
+
+const SHARED_V1_ADDRESSES = {
+  eas: '0xA1207F3BBa224E2c9c3c6D5aF63D0eb1582Ce587',
+  schemaRegistry: '0xA7b39296258348C78294F95B872b282326A97BDF',
+};
+
+const OP_STACK_PREDEPLOY = {
+  eas: '0x4200000000000000000000000000000000000021',
+  schemaRegistry: '0x4200000000000000000000000000000000000020',
+};
+
+export const CHAIN_CONFIGS: Record<string, ChainConfig> = {
+  ethereum: {
+    chainId: 1,
+    ...SHARED_V1_ADDRESSES,
+    defaultRpc: 'https://ethereum-rpc.publicnode.com',
+  },
+  sepolia: {
+    chainId: 11155111,
+    eas: '0xC2679fBD37d54388Ce493F1DB75320D236e1815e',
+    schemaRegistry: '0x0a7E2Ff54e76B8E6659aedc9103FB21c038050D0',
+    defaultRpc: 'https://ethereum-sepolia-rpc.publicnode.com',
+  },
+  base: {
+    chainId: 8453,
+    ...OP_STACK_PREDEPLOY,
+    defaultRpc: 'https://base-rpc.publicnode.com',
+  },
+  'base-sepolia': {
+    chainId: 84532,
+    ...OP_STACK_PREDEPLOY,
+    defaultRpc: 'https://base-sepolia-rpc.publicnode.com',
+  },
+  optimism: {
+    chainId: 10,
+    ...OP_STACK_PREDEPLOY,
+    defaultRpc: 'https://optimism-rpc.publicnode.com',
+  },
+  'optimism-sepolia': {
+    chainId: 11155420,
+    ...OP_STACK_PREDEPLOY,
+    defaultRpc: 'https://optimism-sepolia-rpc.publicnode.com',
+  },
+  arbitrum: {
+    chainId: 42161,
+    eas: '0xbD75f629A22Dc1ceD33dDA0b68c546A1c035c458',
+    schemaRegistry: '0xA310da9c5B885E7fb3fbA9D66E9Ba6Df512b78eB',
+    defaultRpc: 'https://arbitrum-one-rpc.publicnode.com',
+  },
+  'arbitrum-sepolia': {
+    chainId: 421614,
+    eas: '0xaEF4103A04090071165F78D45D83A0C0782c2B2a',
+    schemaRegistry: '0x55D26f9ae0203EF95494AE4C170eD35f4Cf77797',
+    defaultRpc: 'https://arbitrum-sepolia-rpc.publicnode.com',
+  },
+  polygon: {
+    chainId: 137,
+    eas: '0x5E634ef5355f45A855d02D66eCD687b1502AF790',
+    schemaRegistry: '0x7876EEF51A891E737AF8ba5A5E0f0Fd29073D5a7',
+    defaultRpc: 'https://polygon-bor-rpc.publicnode.com',
+  },
+  scroll: {
+    chainId: 534352,
+    eas: '0xC47300428b6AD2c7D03BB76D05A176058b47E6B0',
+    schemaRegistry: '0xD2CDF46556543316e7D34e8eDc4624e2bB95e3B6',
+    defaultRpc: 'https://scroll-rpc.publicnode.com',
+  },
+  linea: {
+    chainId: 59144,
+    eas: '0xaEF4103A04090071165F78D45D83A0C0782c2B2a',
+    schemaRegistry: '0x55D26f9ae0203EF95494AE4C170eD35f4Cf77797',
+    defaultRpc: 'https://linea-rpc.publicnode.com',
+  },
+  celo: {
+    chainId: 42220,
+    eas: '0x72E1d8ccf5a114EA560D5Fd383f1ab3c0C5C1d50',
+    schemaRegistry: '0x5ece93bE0d0D52EeD561Fdbb32e240b43C2CAb6e',
+    defaultRpc: 'https://celo-rpc.publicnode.com',
+  },
+};
+
+export function getChainConfig(name: string): ChainConfig {
+  const config = CHAIN_CONFIGS[name];
+  if (!config) {
+    const available = Object.keys(CHAIN_CONFIGS).join(', ');
+    throw new Error(`Unknown chain "${name}". Available chains: ${available}`);
+  }
+  return config;
+}
+
+export function listChains(): string[] {
+  return Object.keys(CHAIN_CONFIGS);
+}