Revert "use cbor content hashing"

This reverts commit dff675d2e053a7e5ce41f6fd0a080fdaa4bc96dd.

package.json

···
   "dependencies": {
     "@atproto/api": "^0.12.29",
     "@ethereum-attestation-service/eas-sdk": "^2.9.0",
-    "@ipld/dag-cbor": "^9.2.5",
-    "ethers": "^6.15.0",
-    "js-yaml": "^4.1.0"
+    "js-yaml": "^4.1.0",
+    "ethers": "^6.15.0"
   },
   "devDependencies": {
     "@types/js-yaml": "^4.0.9",

pnpm-lock.yaml

···
       '@ethereum-attestation-service/eas-sdk':
         specifier: ^2.9.0
         version: 2.9.0(typescript@5.9.3)(zod@3.25.76)
-      '@ipld/dag-cbor':
-        specifier: ^9.2.5
-        version: 9.2.5
       ethers:
         specifier: ^6.15.0
         version: 6.15.0
···
     resolution: {integrity: sha512-vBZP4NlzfOlerQTnba4aqZoMhE/a9HY7HRqoOPaETQcSQuWEIyZMHGfVu6w9wGtGK5fED5qRs2DteVCjOH60sA==}
     engines: {node: '>=14'}
 
-  '@ipld/dag-cbor@9.2.5':
-    resolution: {integrity: sha512-84wSr4jv30biui7endhobYhXBQzQE4c/wdoWlFrKcfiwH+ofaPg8fwsM8okX9cOzkkrsAsNdDyH3ou+kiLquwQ==}
-    engines: {node: '>=16.0.0', npm: '>=7.0.0'}
-
   '@isaacs/cliui@8.0.2':
     resolution: {integrity: sha512-O8jcjabXaleOG9DQ0+ARXWZBTfnP4WNAqzuiJK7ll44AmxGKv/J2M4TPjxjY3znBCfvBXFzucm1twdyFybFqEA==}
     engines: {node: '>=12'}
···
   camelcase@6.3.0:
     resolution: {integrity: sha512-Gmy6FhYlCY7uOElZUSbxo2UCDH8owEk996gkbrpsgGtrJLM3J7jGxl9Ic7Qwwj4ivOE5AWZWRMecDdF7hqGjFA==}
     engines: {node: '>=10'}
-
-  cborg@4.2.15:
-    resolution: {integrity: sha512-T+YVPemWyXcBVQdp0k61lQp2hJniRNmul0lAwTj2DTS/6dI4eCq/MRMucGqqvFqMBfmnD8tJ9aFtPu5dEGAbgw==}
-    hasBin: true
 
   chai@5.3.3:
     resolution: {integrity: sha512-4zNhdJD/iOjSH0A05ea+Ke6MU5mmpQcbQsSOkgdaUMJ9zTlDTD/GYlwohmIE2u0gaxHYiVHEn1Fw9mZ/ktJWgw==}
···
   ms@2.1.3:
     resolution: {integrity: sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==}
 
-  multiformats@13.4.1:
-    resolution: {integrity: sha512-VqO6OSvLrFVAYYjgsr8tyv62/rCQhPgsZUXLTqoFLSgdkgiUYKYeArbt1uWLlEpkjxQe+P0+sHlbPEte1Bi06Q==}
-
   multiformats@9.9.0:
     resolution: {integrity: sha512-HoMUjhH9T8DDBNT+6xzkrd9ga/XiBI4xLr58LJACwK6G3HTOPeMz4nB4KJs33L2BelrIJa7P0VuNaVF3hMYfjg==}
 
···
 
   '@fastify/busboy@2.1.1': {}
 
-  '@ipld/dag-cbor@9.2.5':
-    dependencies:
-      cborg: 4.2.15
-      multiformats: 13.4.1
-
   '@isaacs/cliui@8.0.2':
     dependencies:
       string-width: 5.1.2
···
       get-intrinsic: 1.3.0
 
   camelcase@6.3.0: {}
-
-  cborg@4.2.15: {}
 
   chai@5.3.3:
     dependencies:
···
       yargs-unparser: 2.0.0
 
   ms@2.1.3: {}
-
-  multiformats@13.4.1: {}
 
   multiformats@9.9.0: {}
 

src/lib/notary.ts

···
 const { EAS, SchemaEncoder, SchemaRegistry, NO_EXPIRATION } = EASPackage;
 
 import type { NotaryConfig, NotarizationResult, AttestationData } from './types';
-import { parseRecordURI, hashContent, getExplorerURL, extractHashFromCID } from './utils';
+import { parseRecordURI, hashContent, getExplorerURL } from './utils';
 
 // Default schemas (deployed by atnotary maintainers)
 const DEFAULT_SCHEMAS = {
···
     currentHash?: string;
   }> {
     try {
+      // 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;
       
-      // Compute hash using DAG-CBOR (same as CID)
-      const currentHash = hashContent(record.value);
-      
-      // Extract hash from CID for comparison
-      const cidHash = extractHashFromCID(currentCid);
-      
       return {
         exists: true,
         cidMatches: currentCid === attestationData.cid,
-        // Now contentHash should match the hash inside CID!
-        hashMatches: currentHash === attestationData.contentHash && currentHash === cidHash,
+        hashMatches: currentHash === attestationData.contentHash,
         currentCid,
         currentHash,
       };
···
       throw error;
     }
   }
-
 
   /**
    * Get signer address

src/lib/utils.ts

···
 import * as crypto from 'crypto';
-import { encode } from '@ipld/dag-cbor';
-import { CID } from 'multiformats/cid';
-import * as sha256 from 'multiformats/hashes/sha256';
 
 export function parseRecordURI(uri: string): { did: string; collection: string; rkey: string } {
   const match = uri.match(/^at:\/\/(did:[^\/]+)\/([^\/]+)\/(.+)$/);
···
   return sorted;
 }
 
+export function hashContent(content: any): string {
+  // Sort keys for deterministic hashing
+  const sortedContent = sortObject(content);
+  const jsonString = JSON.stringify(sortedContent);
+  return '0x' + crypto.createHash('sha256').update(jsonString).digest('hex');
+}
+
 export function getExplorerURL(attestationUID: string, network: string = 'sepolia'): string {
   const explorers: Record<string, string> = {
     'sepolia': 'https://sepolia.easscan.org',
···
   const baseURL = explorers[network] || explorers['sepolia'];
   return `${baseURL}/attestation/view/${attestationUID}`;
 }
-
-// Extract hash bytes from CID
-export function extractHashFromCID(cidString: string): string {
-  const cid = CID.parse(cidString);
-  return '0x' + Buffer.from(cid.multihash.digest).toString('hex');
-}
-
-// Hash content using DAG-CBOR (same as AT Protocol)
-export function hashContent(content: any): string {
-  // Encode as DAG-CBOR (same as AT Protocol)
-  const cborBytes = encode(content);
-  
-  // Hash with SHA-256
-  const hash = crypto.createHash('sha256').update(cborBytes).digest('hex');
-  
-  return '0x' + hash;
-}
-
-// Verify content matches CID
-export function verifyCID(content: any, cidString: string): boolean {
-  const computedHash = hashContent(content);
-  const cidHash = extractHashFromCID(cidString);
-  return computedHash === cidHash;
-}

tests/integration/notary.test.ts

···
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { ATProtocolNotary } from '../../src/lib/notary';
-import { CID } from 'multiformats/cid';
-import * as sha256 from 'multiformats/hashes/sha2';
-import { encode } from '@ipld/dag-cbor';
-
-// Generate real valid CIDs for test data
-const TEST_CONTENT_1 = { text: 'Test post', createdAt: '2024-01-01' };
-const TEST_CONTENT_2 = { text: 'Modified post', createdAt: '2024-01-02' };
-
-// Create real CIDs
-async function createCID(content: any): Promise<string> {
-  const bytes = encode(content);
-  const hash = await sha256.sha256.digest(bytes);
-  const cid = CID.create(1, 0x71, hash); // CIDv1, dag-cbor
-  return cid.toString();
-}
-
-// Generate CIDs at module level (needs to be async)
-let TEST_CID_1: string;
-let TEST_CID_2: string;
-let TEST_HASH_1: string;
 
 // Mock external dependencies
 vi.mock('@atproto/api', () => ({
···
         repo: {
           getRecord: vi.fn().mockResolvedValue({
             data: {
-              value: TEST_CONTENT_1,
-              cid: TEST_CID_1,
+              value: { text: 'Test post', createdAt: '2024-01-01' },
+              cid: 'bafyreiabc123',
             },
           }),
         },
···
         encodeData: vi.fn().mockReturnValue('0xencodeddata'),
         decodeData: vi.fn().mockReturnValue([
           { name: 'recordURI', value: { value: 'at://did:plc:test/app.bsky.feed.post/123' } },
-          { name: 'cid', value: { value: TEST_CID_1 } },
-          { name: 'contentHash', value: { value: TEST_HASH_1 } },
+          { name: 'cid', value: { value: 'bafyreiabc123' } },
+          { name: 'contentHash', value: { value: '0xa64b286ffd5cc55c57f4e9c74d1122aa081dc5f662648cb5cc5ced74e0e12cd5' } },
           { name: 'pds', value: { value: 'https://pds.example.com' } },
           { name: 'timestamp', value: { value: 1234567890 } },
         ]),
···
 global.fetch = vi.fn();
 
 describe('ATProtocolNotary', () => {
-  beforeEach(async () => {
+  beforeEach(() => {
     vi.clearAllMocks();
     
-    // Generate real CIDs
-    TEST_CID_1 = await createCID(TEST_CONTENT_1);
-    TEST_CID_2 = await createCID(TEST_CONTENT_2);
-    
-    // Generate real hash
-    const { hashContent } = await import('../../src/lib/utils');
-    TEST_HASH_1 = hashContent(TEST_CONTENT_1);
-    
     // Mock DID resolution
     (global.fetch as any).mockResolvedValue({
       ok: true,
···
       const result = await notary.fetchRecord('at://did:plc:test/app.bsky.feed.post/123');
 
       expect(result.record.value.text).toBe('Test post');
-      expect(result.record.cid).toBe(TEST_CID_1);
+      expect(result.record.cid).toBe('bafyreiabc123');
       expect(result.pds).toBe('https://pds.example.com');
     });
   });
···
 
       expect(result.attestationUID).toBe('0xattestationuid123');
       expect(result.recordURI).toBe('at://did:plc:test/app.bsky.feed.post/123');
-      expect(result.cid).toBe(TEST_CID_1);
+      expect(result.cid).toBe('bafyreiabc123');
       expect(result.pds).toBe('https://pds.example.com');
       expect(result.transactionHash).toBeTruthy();
     });
···
 
       expect(result.uid).toBe('0xattestationuid123');
       expect(result.recordURI).toBe('at://did:plc:test/app.bsky.feed.post/123');
-      expect(result.cid).toBe(TEST_CID_1);
+      expect(result.cid).toBe('bafyreiabc123');
       expect(result.pds).toBe('https://pds.example.com');
       expect(result.attester).toBe('0xattester');
       expect(result.revoked).toBe(false);
···
 
       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).toBe(TEST_CID_1);
-      expect(comparison.currentHash).toBe(TEST_HASH_1);
+      expect(comparison.currentCid).toBeTruthy();
+      expect(comparison.currentHash).toBeTruthy();
     });
     
     it('should detect changed content', async () => {
-      // Mock different content
+      // Mock different CID and hash
       const { AtpAgent } = await import('@atproto/api');
-      (AtpAgent as any).mockImplementationOnce(() => ({
+      (AtpAgent as any).mockImplementation(() => ({
         com: {
           atproto: {
             repo: {
               getRecord: vi.fn().mockResolvedValue({
                 data: {
-                  value: TEST_CONTENT_2,
-                  cid: TEST_CID_2,
+                  value: { text: 'Modified post', createdAt: '2024-01-02' },
+                  cid: 'bafyreidifferent123',
                 },
               }),
             },
···
 
       expect(comparison.exists).toBe(true);
       expect(comparison.cidMatches).toBe(false);
-      expect(comparison.currentCid).toBe(TEST_CID_2);
+      expect(comparison.hashMatches).toBe(false);
     });
   });
+
 });

tests/unit/utils.test.ts

···
 import { describe, it, expect } from 'vitest';
-import { parseRecordURI, hashContent, getExplorerURL, extractHashFromCID, verifyCID } from '../../src/lib/utils';
+import { parseRecordURI, hashContent, getExplorerURL } from '../../src/lib/utils';
 
 describe('parseRecordURI', () => {
   it('should parse valid AT Protocol URI', () => {
···
   });
 });
 
-describe('hashContent with DAG-CBOR', () => {
-  it('should produce hash that matches CID', () => {
+describe('hashContent', () => {
+  it('should generate consistent SHA-256 hash', () => {
     const content = { text: 'Hello World', createdAt: '2024-01-01' };
-    const contentHash = hashContent(content);
+    const hash1 = hashContent(content);
+    const hash2 = hashContent(content);
     
-    // This hash should match the hash inside a CID of the same content
-    expect(contentHash).toMatch(/^0x[a-f0-9]{64}$/);
+    expect(hash1).toBe(hash2);
+    expect(hash1).toMatch(/^0x[a-f0-9]{64}$/);
   });
-});
 
-describe('extractHashFromCID', () => {
-  it('should extract hash from valid CID', () => {
-    const cid = 'bafyreig3iwk4yuvewp54jkzplqw4vxae5o3smtcfn2jxk7x4ewhicbuw4m'; // Real CID
-    const hash = extractHashFromCID(cid);
+  it('should generate different hashes for different content', () => {
+    const content1 = { text: 'Hello' };
+    const content2 = { text: 'World' };
     
-    expect(hash).toMatch(/^0x[a-f0-9]{64}$/);
+    expect(hashContent(content1)).not.toBe(hashContent(content2));
   });
-});
 
-describe('verifyCID', () => {
-  it('should verify content matches CID', () => {
-    const content = { text: 'Test' };
-    const contentHash = hashContent(content);
+  it('should be order-sensitive', () => {
+    const content1 = { a: 1, b: 2 };
+    const content2 = { b: 2, a: 1 };
+    
+    // JSON.stringify is order-sensitive
+    const hash1 = hashContent(content1);
+    const hash2 = hashContent(content2);
     
-    // In real usage, CID and content should match
-    // This would need a real CID from AT Protocol
+    expect(hash1).toBeTruthy();
+    expect(hash2).toBeTruthy();
   });
 });