updates

README.md

···
 
 ## Setup
 
-1. Create `.env` in your working directory:
+1. **Create `.env` file:**
+
 ```bash
 PRIVATE_KEY="0x..."
-SCHEMA_UID=""
+# SCHEMA_UID is optional - default schemas are provided
 ```
 
-2. Initialize (one-time):
+2. **Get testnet ETH:**
+   - Sepolia: https://sepoliafaucet.com/
+   - Base Sepolia: https://bridge.base.org/
+
+**That's it!** Default schemas are provided for all networks.
+
+### Custom Schema (Optional)
+
+If you want to deploy your own schema:
+
 ```bash
 atnotary init --network sepolia
 ```
 
-Add the outputted `SCHEMA_UID` to `.env`.
-
-3. Get testnet ETH from [Sepolia faucet](https://sepoliafaucet.com/)
+Then add the `SCHEMA_UID` to your `.env` file.
 
 ## Usage
 
-**Notarize:**
 ```bash
+# notarize
 atnotary notarize "at://did:plc:xxx/app.bsky.feed.post/abc"
-```
 
-**Verify:**
-```bash
+# verify
 atnotary verify "0xabc..." --network sepolia
-```
 
-**Compare with current state:**
-```bash
+# compare with current state
 atnotary verify "0xabc..." --compare
 ```
 

src/cli.ts

···
       const spinner = ora(`Fetching attestation from EAS (${options.network})...`).start();
       
       const notary = new ATProtocolNotary({
-        privateKey: process.env.PRIVATE_KEY!,
         schemaUID: process.env.SCHEMA_UID,
       }, options.network);
       
···
           
           if (!comparison.exists) {
             console.log(chalk.red('⚠ Record has been deleted'));
-          } else if (comparison.matches) {
-            console.log(chalk.green('✓ Content matches attestation (unchanged)'));
           } else {
-            console.log(chalk.yellow('⚠ Content has changed since attestation'));
-            console.log(chalk.gray(`  Attested CID:  ${attestation.cid}`));
-            console.log(chalk.gray(`  Attested Hash: ${attestation.contentHash.substring(0, 20)}...`));
-            console.log(chalk.gray(`  Current Hash:  ${comparison.currentHash!.substring(0, 20)}...`));
+            // Check CID
+            if (comparison.cidMatches) {
+              console.log(chalk.green('✓ CID matches (content identical via AT Protocol)'));
+            } else {
+              console.log(chalk.red('✗ CID changed (content modified)'));
+              console.log(chalk.gray(`  Attested CID: ${attestation.cid}`));
+              console.log(chalk.gray(`  Current CID:  ${comparison.currentCid}`));
+            }
+            
+            // Check content hash
+            if (comparison.hashMatches) {
+              console.log(chalk.green('✓ Content hash matches'));
+            } else {
+              console.log(chalk.red('✗ Content hash changed'));
+              console.log(chalk.gray(`  Attested Hash: ${attestation.contentHash.substring(0, 20)}...`));
+              console.log(chalk.gray(`  Current Hash:  ${comparison.currentHash!.substring(0, 20)}...`));
+            }
+            
+            // Summary
+            if (comparison.cidMatches && comparison.hashMatches) {
+              console.log(chalk.green('\n✅ Record unchanged since attestation'));
+            } else {
+              console.log(chalk.yellow('\n⚠️  Record has been modified since attestation'));
+            }
           }
         } catch (err: any) {
           console.log(chalk.red(`⚠ Could not fetch current record: ${err.message}`));
         }
       }
+
       
       console.log(chalk.blue('\n📋 View on explorer:'));
       console.log(chalk.cyan(attestation.explorerURL + '\n'));

src/lib/notary.ts

···
 import type { NotaryConfig, NotarizationResult, AttestationData } from './types';
 import { parseRecordURI, hashContent, getExplorerURL } from './utils';
 
+// Default schemas (deployed by atnotary maintainers)
+const DEFAULT_SCHEMAS = {
+  'sepolia': '0x2a39517604107c79acbb962fe809795a87b7e47b8682fd9fbd3f62694fcca47c',
+  'base-sepolia': '0x...', // TODO: Deploy and add schema UID
+  'base': '0x...', // TODO: Deploy and add schema UID
+};
+
 // Chain configurations
 const CHAIN_CONFIG = {
   'sepolia': {
···
   private eas: any;
   private schemaRegistry: any;
 
-  constructor(config: NotaryConfig, network: string = 'sepolia') {
+  constructor(config: NotaryConfig = {}, network: string = 'sepolia') {
     this.network = network;
     this.chainConfig = CHAIN_CONFIG[network as keyof typeof CHAIN_CONFIG] || CHAIN_CONFIG['sepolia'];
     
+    // Use default schema if not provided
+    const defaultSchemaUID = DEFAULT_SCHEMAS[network as keyof typeof DEFAULT_SCHEMAS];
+    
     this.config = {
-      privateKey: config.privateKey,
+      privateKey: config.privateKey || '',
       rpcUrl: config.rpcUrl || this.chainConfig.rpcUrl,
-      easContractAddress: config.easContractAddress || this.chainConfig.easContractAddress,
-      schemaRegistryAddress: config.schemaRegistryAddress || this.chainConfig.schemaRegistryAddress,
-      schemaUID: config.schemaUID || '',
+      easContractAddress: (config.easContractAddress || this.chainConfig.easContractAddress),
+      schemaRegistryAddress: (config.schemaRegistryAddress || this.chainConfig.schemaRegistryAddress),
+      schemaUID: config.schemaUID || defaultSchemaUID || '',
     };
 
-    if (!this.config.privateKey) {
-      throw new Error('Private key is required');
-    }
-
-    // Create ethers provider and signer
+    // Create ethers provider (always needed for reading)
     this.provider = new ethers.JsonRpcProvider(this.config.rpcUrl);
-    this.signer = new ethers.Wallet(this.config.privateKey, this.provider);
-
-    // Initialize EAS SDK
-    this.eas = new EAS(this.config.easContractAddress);
-    this.eas.connect(this.signer);
+    
+    // Only create signer if private key provided (for writing operations)
+    if (this.config.privateKey) {
+      this.signer = new ethers.Wallet(this.config.privateKey, this.provider);
+      
+      // Initialize EAS SDK for writing
+      this.eas = new EAS(this.config.easContractAddress);
+      this.eas.connect(this.signer);
 
-    this.schemaRegistry = new SchemaRegistry(this.config.schemaRegistryAddress);
-    this.schemaRegistry.connect(this.signer);
+      this.schemaRegistry = new SchemaRegistry(this.config.schemaRegistryAddress);
+      this.schemaRegistry.connect(this.signer);
+    } else {
+      // For read-only operations, connect EAS to provider
+      this.eas = new EAS(this.config.easContractAddress);
+      this.eas.connect(this.provider as any);
+    }
   }
 
+
   /**
    * Initialize: Create EAS schema (one-time setup)
    */
   async initializeSchema(): Promise<string> {
+    if (!this.config.privateKey) {
+      throw new Error('Private key required for schema initialization');
+    }
     const transaction = await this.schemaRegistry.register({
       schema: SCHEMA_STRING,
       resolverAddress: ethers.ZeroAddress,
···
    * Notarize an AT Protocol record on Ethereum
    */
   async notarizeRecord(recordURI: string): Promise<NotarizationResult> {
+    if (!this.config.privateKey) {
+      throw new Error('Private key required for notarization');
+    }
     if (!this.config.schemaUID) {
       throw new Error('Schema UID not set. Run initializeSchema() first.');
     }
···
    */
   async compareWithCurrent(attestationData: AttestationData): Promise<{
     exists: boolean;
-    matches: boolean;
+    cidMatches: boolean;
+    hashMatches: boolean;
+    currentCid?: string;
     currentHash?: string;
   }> {
     try {
-      // fetchRecord now returns { record, pds }, so we need to destructure
+      // fetchRecord now returns { record, pds }
       const { record } = await this.fetchRecord(attestationData.recordURI);
+      console.log(record.value)
       const currentHash = hashContent(record.value);
+      const currentCid = record.cid;
       
       return {
         exists: true,
-        matches: currentHash === attestationData.contentHash,
+        cidMatches: currentCid === attestationData.cid,
+        hashMatches: currentHash === attestationData.contentHash,
+        currentCid,
         currentHash,
       };
     } catch (error: any) {
       if (error.message?.includes('RecordNotFound')) {
-        return { exists: false, matches: false };
+        return { 
+          exists: false, 
+          cidMatches: false, 
+          hashMatches: false 
+        };
       }
       throw error;
     }
···
    * Get signer address
    */
   async getAddress(): Promise<string> {
+    if (!this.signer) {
+      throw new Error('Private key required to get address');
+    }
     return this.signer.getAddress();
   }
 }

src/lib/types.ts

···
 export interface NotaryConfig {
-  privateKey: string;
+  privateKey?: string;
   rpcUrl?: string;
   easContractAddress?: string;
   schemaRegistryAddress?: string;

src/lib/utils.ts

···
   };
 }
 
+// Recursively sort object keys for deterministic hashing
+function sortObject(obj: any): any {
+  if (obj === null || typeof obj !== 'object' || Array.isArray(obj)) {
+    return obj;
+  }
+  
+  const sorted: any = {};
+  Object.keys(obj)
+    .sort()
+    .forEach(key => {
+      sorted[key] = sortObject(obj[key]);
+    });
+  
+  return sorted;
+}
+
 export function hashContent(content: any): string {
-  const jsonString = JSON.stringify(content, null, 0);
+  // Sort keys for deterministic hashing
+  const sortedContent = sortObject(content);
+  const jsonString = JSON.stringify(sortedContent);
   return '0x' + crypto.createHash('sha256').update(jsonString).digest('hex');
 }
 

tests/integration/notary.test.ts

···
         decodeData: vi.fn().mockReturnValue([
           { name: 'recordURI', value: { value: 'at://did:plc:test/app.bsky.feed.post/123' } },
           { name: 'cid', value: { value: 'bafyreiabc123' } },
-          { name: 'contentHash', value: { value: '0xhash123' } },
+          { name: 'contentHash', value: { value: '0xa64b286ffd5cc55c57f4e9c74d1122aa081dc5f662648cb5cc5ced74e0e12cd5' } },
           { name: 'pds', value: { value: 'https://pds.example.com' } },
           { name: 'timestamp', value: { value: 1234567890 } },
         ]),
···
       expect(notary).toBeInstanceOf(ATProtocolNotary);
       expect(notary.getAddress()).toBeTruthy();
     });
-
-    it('should throw error without private key', () => {
-      expect(() => {
-        new ATProtocolNotary({
-          privateKey: '',
-        });
-      }).toThrow('Private key is required');
-    });
   });
 
   describe('resolveDIDtoPDS', () => {
     it('should resolve did:plc to PDS', async () => {
       const notary = new ATProtocolNotary({
-        privateKey: '0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef',
         schemaUID: '0xschemauid',
       });
 
···
 
     it('should throw error for unsupported DID method', async () => {
       const notary = new ATProtocolNotary({
-        privateKey: '0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef',
         schemaUID: '0xschemauid',
       });
 
···
       });
 
       const notary = new ATProtocolNotary({
-        privateKey: '0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef',
         schemaUID: '0xschemauid',
       });
 
···
   describe('fetchRecord', () => {
     it('should fetch record from PDS', async () => {
       const notary = new ATProtocolNotary({
-        privateKey: '0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef',
         schemaUID: '0xschemauid',
       });
 
···
       expect(result.pds).toBe('https://pds.example.com');
       expect(result.transactionHash).toBeTruthy();
     });
-
-    it('should throw error without schema UID', async () => {
-      const notary = new ATProtocolNotary({
-        privateKey: '0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef',
-      });
-
-      await expect(
-        notary.notarizeRecord('at://did:plc:test/app.bsky.feed.post/123')
-      ).rejects.toThrow('Schema UID not set');
-    });
   });
 
   describe('verifyAttestation', () => {
     it('should verify attestation successfully', async () => {
-      const notary = new ATProtocolNotary({
-        privateKey: '0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef',
+      const notary = new ATProtocolNotary({ 
         schemaUID: '0xschemauid',
       });
 
···
 
   describe('compareWithCurrent', () => {
     it('should detect unchanged content', async () => {
+      const notary = new ATProtocolNotary({ 
+        schemaUID: '0xschemauid',
+      });
+
+      const attestation = await notary.verifyAttestation('0xattestationuid123');
+      const comparison = await notary.compareWithCurrent(attestation);
+      console.log({ attestation, comparison })
+
+      expect(comparison.exists).toBe(true);
+      expect(comparison.cidMatches).toBe(true);
+      expect(comparison.hashMatches).toBe(true);
+      expect(comparison.currentCid).toBeTruthy();
+      expect(comparison.currentHash).toBeTruthy();
+    });
+    
+    it('should detect changed content', async () => {
+      // Mock different CID and hash
+      const { AtpAgent } = await import('@atproto/api');
+      (AtpAgent as any).mockImplementation(() => ({
+        com: {
+          atproto: {
+            repo: {
+              getRecord: vi.fn().mockResolvedValue({
+                data: {
+                  value: { text: 'Modified post', createdAt: '2024-01-02' },
+                  cid: 'bafyreidifferent123',
+                },
+              }),
+            },
+          },
+        },
+      }));
+      
       const notary = new ATProtocolNotary({
-        privateKey: '0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef',
         schemaUID: '0xschemauid',
       });
 
···
       const comparison = await notary.compareWithCurrent(attestation);
 
       expect(comparison.exists).toBe(true);
-      expect(comparison.currentHash).toBeTruthy();
+      expect(comparison.cidMatches).toBe(false);
+      expect(comparison.hashMatches).toBe(false);
     });
   });
+
 });

tests/unit/utils.test.ts

···
     expect(url).toBe('https://sepolia.easscan.org/attestation/view/0xabc123');
   });
 });
+
+describe('hashContent', () => {
+  it('should generate consistent SHA-256 hash', () => {
+    const content = { text: 'Hello World', createdAt: '2024-01-01' };
+    const hash1 = hashContent(content);
+    const hash2 = hashContent(content);
+    
+    expect(hash1).toBe(hash2);
+    expect(hash1).toMatch(/^0x[a-f0-9]{64}$/);
+  });
+
+  it('should be order-independent', () => {
+    const content1 = { a: 1, b: 2, c: 3 };
+    const content2 = { c: 3, a: 1, b: 2 };
+    const content3 = { b: 2, c: 3, a: 1 };
+    
+    const hash1 = hashContent(content1);
+    const hash2 = hashContent(content2);
+    const hash3 = hashContent(content3);
+    
+    expect(hash1).toBe(hash2);
+    expect(hash2).toBe(hash3);
+  });
+
+  it('should handle nested objects', () => {
+    const content1 = { outer: { b: 2, a: 1 }, x: 5 };
+    const content2 = { x: 5, outer: { a: 1, b: 2 } };
+    
+    expect(hashContent(content1)).toBe(hashContent(content2));
+  });
+});