update

.gitignore

···
 .env
 .DS_Store
-node_modules
+node_modules
+bun.lock
+dist

package.json

···
   "dependencies": {
     "@atproto/api": "^0.12.29",
     "@ethereum-attestation-service/eas-sdk": "^2.9.0",
-    "viem": "^2.38.0"
+    "ethers": "^6.15.0"
   },
   "devDependencies": {
     "@types/node": "^20.19.21",

pnpm-lock.yaml

···
       '@ethereum-attestation-service/eas-sdk':
         specifier: ^2.9.0
         version: 2.9.0(typescript@5.9.3)(zod@3.25.76)
-      viem:
-        specifier: ^2.38.0
-        version: 2.38.0(typescript@5.9.3)(zod@3.25.76)
+      ethers:
+        specifier: ^6.15.0
+        version: 6.15.0
     devDependencies:
       '@types/node':
         specifier: ^20.19.21

src/cli.ts

···
       
       spinner.succeed('Initialized');
       
-      spinner.start('Fetching record from AT Protocol...');
-      const record = await notary.fetchRecord(recordURI);
-      spinner.succeed('Record fetched');
+      spinner.start('Resolving DID to PDS...');
+      const { record, pds } = await notary.fetchRecord(recordURI);
+      spinner.succeed(`Record fetched from PDS: ${pds}`);
       
       console.log(chalk.gray('\nRecord preview:'));
       console.log(chalk.gray(JSON.stringify(record.value, null, 2).substring(0, 200) + '...\n'));
       
-      spinner.start('Creating attestation...');
+      spinner.start('Creating attestation on Ethereum...');
       const result = await notary.notarizeRecord(recordURI);
       spinner.succeed('Attestation created!');
       
       console.log(chalk.green('\n✅ Notarization Complete!\n'));
       console.log(chalk.blue('Attestation UID:'), chalk.cyan(result.attestationUID));
       console.log(chalk.blue('Record URI:'), chalk.gray(result.recordURI));
+      console.log(chalk.blue('CID:'), chalk.gray(result.cid));
       console.log(chalk.blue('Content Hash:'), chalk.gray(result.contentHash));
-      console.log(chalk.blue('Lexicon:'), chalk.gray(result.lexicon));
+      console.log(chalk.blue('PDS:'), chalk.gray(result.pds));
       console.log(chalk.blue('Transaction:'), chalk.gray(result.transactionHash));
       
       console.log(chalk.yellow('\n📋 View on EAS Explorer:'));
···
     }
   });
 
+
 // Verify command
 program
   .command('verify <attestationUID>')
···
       console.log(chalk.green('\n✅ Attestation Valid\n'));
       console.log(chalk.blue('UID:'), chalk.cyan(attestation.uid));
       console.log(chalk.blue('Record URI:'), chalk.gray(attestation.recordURI));
+      console.log(chalk.blue('CID:'), chalk.gray(attestation.cid));
       console.log(chalk.blue('Content Hash:'), chalk.gray(attestation.contentHash));
-      console.log(chalk.blue('Lexicon:'), chalk.gray(attestation.lexicon));
+      console.log(chalk.blue('PDS:'), chalk.gray(attestation.pds));
       console.log(chalk.blue('Timestamp:'), chalk.gray(new Date(attestation.timestamp * 1000).toISOString()));
       console.log(chalk.blue('Attester:'), chalk.gray(attestation.attester));
-      console.log(chalk.blue('Revoked:'), attestation.revoked ? chalk.red('Yes') : chalk.green('No'));
       
       // Compare with current if requested
       if (options.compare) {
         console.log(chalk.yellow('\n🔄 Comparing with current record...'));
         
-        const comparison = await notary.compareWithCurrent(attestation);
-        
-        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(`  Original: ${attestation.contentHash.substring(0, 20)}...`));
-          console.log(chalk.gray(`  Current:  ${comparison.currentHash!.substring(0, 20)}...`));
+        try {
+          const comparison = await notary.compareWithCurrent(attestation);
+          
+          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)}...`));
+          }
+        } catch (err: any) {
+          console.log(chalk.red(`⚠ Could not fetch current record: ${err.message}`));
         }
       }
       
···
       process.exit(1);
     }
   });
+
 
 program.parse();

src/lib/notary.ts

···
 import { AtpAgent } from '@atproto/api';
-import {
-  createPublicClient,
-  createWalletClient,
-  http,
-  type Address,
-  type Hash,
-  type PublicClient,
-  type WalletClient,
-  zeroAddress,
-  encodeAbiParameters,
-  parseAbiParameters,
-  decodeAbiParameters,
-  keccak256,
-  toHex,
-} from 'viem';
-import { privateKeyToAccount } from 'viem/accounts';
-import { sepolia, base, baseSepolia } from 'viem/chains';
+import { ethers } from 'ethers';
+import EASPackage from '@ethereum-attestation-service/eas-sdk';
+const { EAS, SchemaEncoder, SchemaRegistry, NO_EXPIRATION } = EASPackage;
+
 import type { NotaryConfig, NotarizationResult, AttestationData } from './types';
 import { parseRecordURI, hashContent, getExplorerURL } from './utils';
 
 // Chain configurations
 const CHAIN_CONFIG = {
   'sepolia': {
-    chain: sepolia,
     rpcUrl: 'https://1rpc.io/sepolia',
-    easContractAddress: '0xC2679fBD37d54388Ce493F1DB75320D236e1815e' as Address,
-    schemaRegistryAddress: '0x0a7E2Ff54e76B8E6659aedc9103FB21c038050D0' as Address,
+    easContractAddress: '0xC2679fBD37d54388Ce493F1DB75320D236e1815e',
+    schemaRegistryAddress: '0x0a7E2Ff54e76B8E6659aedc9103FB21c038050D0',
   },
   'base-sepolia': {
-    chain: baseSepolia,
     rpcUrl: 'https://sepolia.base.org',
-    easContractAddress: '0x4200000000000000000000000000000000000021' as Address,
-    schemaRegistryAddress: '0x4200000000000000000000000000000000000020' as Address,
+    easContractAddress: '0x4200000000000000000000000000000000000021',
+    schemaRegistryAddress: '0x4200000000000000000000000000000000000020',
   },
   'base': {
-    chain: base,
     rpcUrl: 'https://mainnet.base.org',
-    easContractAddress: '0x4200000000000000000000000000000000000021' as Address,
-    schemaRegistryAddress: '0x4200000000000000000000000000000000000020' as Address,
+    easContractAddress: '0x4200000000000000000000000000000000000021',
+    schemaRegistryAddress: '0x4200000000000000000000000000000000000020',
   }
 };
 
-const SCHEMA_STRING = "string recordURI,bytes32 contentHash,string lexicon,uint256 timestamp";
-
-// EAS Contract ABIs
-const SCHEMA_REGISTRY_ABI = [
-  {
-    type: 'function',
-    name: 'register',
-    inputs: [
-      { name: 'schema', type: 'string' },
-      { name: 'resolver', type: 'address' },
-      { name: 'revocable', type: 'bool' }
-    ],
-    outputs: [{ name: 'uid', type: 'bytes32' }],
-    stateMutability: 'nonpayable',
-  },
-] as const;
-
-const EAS_ABI = [
-  {
-    type: 'function',
-    name: 'attest',
-    inputs: [
-      {
-        name: 'request',
-        type: 'tuple',
-        components: [
-          { name: 'schema', type: 'bytes32' },
-          {
-            name: 'data',
-            type: 'tuple',
-            components: [
-              { name: 'recipient', type: 'address' },
-              { name: 'expirationTime', type: 'uint64' },
-              { name: 'revocable', type: 'bool' },
-              { name: 'refUID', type: 'bytes32' },
-              { name: 'data', type: 'bytes' },
-              { name: 'value', type: 'uint256' },
-            ],
-          },
-        ],
-      },
-    ],
-    outputs: [{ name: 'uid', type: 'bytes32' }],
-    stateMutability: 'payable',
-  },
-  {
-    type: 'function',
-    name: 'getAttestation',
-    inputs: [{ name: 'uid', type: 'bytes32' }],
-    outputs: [
-      {
-        name: 'attestation',
-        type: 'tuple',
-        components: [
-          { name: 'uid', type: 'bytes32' },
-          { name: 'schema', type: 'bytes32' },
-          { name: 'time', type: 'uint64' },
-          { name: 'expirationTime', type: 'uint64' },
-          { name: 'revocationTime', type: 'uint64' },
-          { name: 'refUID', type: 'bytes32' },
-          { name: 'recipient', type: 'address' },
-          { name: 'attester', type: 'address' },
-          { name: 'revocable', type: 'bool' },
-          { name: 'data', type: 'bytes' },
-        ],
-      },
-    ],
-    stateMutability: 'view',
-  },
-] as const;
-
-// Helper to encode attestation data
-function encodeAttestationData(params: {
-  recordURI: string;
-  contentHash: Hash;
-  lexicon: string;
-  timestamp: number;
-}): Hash {
-  return encodeAbiParameters(
-    parseAbiParameters(SCHEMA_STRING),
-    [params.recordURI, params.contentHash, params.lexicon, BigInt(params.timestamp)]
-  );
-}
-
-// Helper to decode attestation data
-function decodeAttestationData(data: Hash): {
-  recordURI: string;
-  contentHash: Hash;
-  lexicon: string;
-  timestamp: number;
-} {
-  const [recordURI, contentHash, lexicon, timestamp] = decodeAbiParameters(
-    parseAbiParameters(SCHEMA_STRING),
-    data
-  );
-  
-  return {
-    recordURI: recordURI as string,
-    contentHash: contentHash as Hash,
-    lexicon: lexicon as string,
-    timestamp: Number(timestamp),
-  };
-}
+const SCHEMA_STRING = "string recordURI,string cid,bytes32 contentHash,string pds,uint256 timestamp";
 
 export class ATProtocolNotary {
   private config: Required<NotaryConfig>;
-  private publicClient: PublicClient;
-  private walletClient: WalletClient;
-  private account: ReturnType<typeof privateKeyToAccount>;
+  private provider: ethers.JsonRpcProvider;
+  private signer: ethers.Wallet;
   private network: string;
   private chainConfig: typeof CHAIN_CONFIG[keyof typeof CHAIN_CONFIG];
+  private eas: any;
+  private schemaRegistry: any;
 
   constructor(config: NotaryConfig, network: string = 'sepolia') {
     this.network = network;
···
     this.config = {
       privateKey: config.privateKey,
       rpcUrl: config.rpcUrl || this.chainConfig.rpcUrl,
-      easContractAddress: (config.easContractAddress || this.chainConfig.easContractAddress) as Address,
-      schemaRegistryAddress: (config.schemaRegistryAddress || this.chainConfig.schemaRegistryAddress) as Address,
+      easContractAddress: config.easContractAddress || this.chainConfig.easContractAddress,
+      schemaRegistryAddress: config.schemaRegistryAddress || this.chainConfig.schemaRegistryAddress,
       schemaUID: config.schemaUID || '',
     };
 
···
       throw new Error('Private key is required');
     }
 
-    // Create account from private key
-    this.account = privateKeyToAccount(this.config.privateKey as Hash);
+    // Create ethers provider and signer
+    this.provider = new ethers.JsonRpcProvider(this.config.rpcUrl);
+    this.signer = new ethers.Wallet(this.config.privateKey, this.provider);
 
-    // Create public client (for reading)
-    this.publicClient = createPublicClient({
-      chain: this.chainConfig.chain,
-      transport: http(this.config.rpcUrl),
-    });
+    // Initialize EAS SDK
+    this.eas = new EAS(this.config.easContractAddress);
+    this.eas.connect(this.signer);
 
-    // Create wallet client (for writing)
-    this.walletClient = createWalletClient({
-      account: this.account,
-      chain: this.chainConfig.chain,
-      transport: http(this.config.rpcUrl),
-    });
+    this.schemaRegistry = new SchemaRegistry(this.config.schemaRegistryAddress);
+    this.schemaRegistry.connect(this.signer);
   }
 
   /**
    * Initialize: Create EAS schema (one-time setup)
    */
   async initializeSchema(): Promise<string> {
-
-    // Call register function on SchemaRegistry
-    const hash = await this.walletClient.writeContract({
-      address: this.config.schemaRegistryAddress,
-      abi: SCHEMA_REGISTRY_ABI,
-      functionName: 'register',
-      args: [SCHEMA_STRING, zeroAddress, true],
+    const transaction = await this.schemaRegistry.register({
+      schema: SCHEMA_STRING,
+      resolverAddress: ethers.ZeroAddress,
+      revocable: true,
     });
 
-    // Wait for transaction receipt
-    const receipt = await this.publicClient.waitForTransactionReceipt({ hash });
+    await transaction.wait();
+
+    // Return the transaction hash as schema UID placeholder
+    return transaction.tx?.hash;
+  }
 
-    // Extract schema UID from logs
-    // The SchemaRegistered event emits the schema UID
-    if (receipt.logs.length > 0) {
-      // The first topic after the event signature is the schema UID
-      const schemaUID = receipt.logs[0].topics[1];
-      if (schemaUID) {
-        return schemaUID;
+  /**
+   * Resolve DID to PDS endpoint
+   */
+  async resolveDIDtoPDS(did: string): Promise<string> {
+    // For did:plc, resolve via PLC directory
+    if (did.startsWith('did:plc:')) {
+      const response = await fetch(`https://plc.directory/${did}`);
+      if (!response.ok) {
+        throw new Error(`Failed to resolve DID: ${did}`);
       }
+      
+      const didDocument: any = await response.json();
+      
+      // Find the PDS service endpoint
+      const pdsService = didDocument.service?.find(
+        (s: any) => s.id === '#atproto_pds' || s.type === 'AtprotoPersonalDataServer'
+      );
+      
+      if (!pdsService?.serviceEndpoint) {
+        throw new Error(`No PDS endpoint found for DID: ${did}`);
+      }
+      
+      return pdsService.serviceEndpoint;
     }
-
-    // Fallback: return transaction hash
-    return hash;
+    
+    // For did:web, resolve via web
+    if (did.startsWith('did:web:')) {
+      const domain = did.replace('did:web:', '');
+      const response = await fetch(`https://${domain}/.well-known/did.json`);
+      if (!response.ok) {
+        throw new Error(`Failed to resolve DID: ${did}`);
+      }
+      
+      const didDocument: any = await response.json();
+      const pdsService = didDocument.service?.find(
+        (s: any) => s.id === '#atproto_pds' || s.type === 'AtprotoPersonalDataServer'
+      );
+      
+      if (!pdsService?.serviceEndpoint) {
+        throw new Error(`No PDS endpoint found for DID: ${did}`);
+      }
+      
+      return pdsService.serviceEndpoint;
+    }
+    
+    throw new Error(`Unsupported DID method: ${did}`);
   }
 
   /**
-   * Fetch a record from AT Protocol
+   * Fetch a record from AT Protocol (directly from PDS)
    */
-  async fetchRecord(recordURI: string): Promise<any> {
+  async fetchRecord(recordURI: string): Promise<{ record: any; pds: string }> {
     const { did, collection, rkey } = parseRecordURI(recordURI);
     
-    const agent = new AtpAgent({ service: 'https://public.api.bsky.app' });
+    // Resolve DID to PDS
+    const pds = await this.resolveDIDtoPDS(did);
+    
+    // Create agent pointing to user's PDS
+    const agent = new AtpAgent({ service: pds });
     
     const response = await agent.com.atproto.repo.getRecord({
       repo: did,
···
       rkey: rkey
     });
 
-    return response.data;
+    return {
+      record: response.data,
+      pds: pds
+    };
   }
 
-/**
- * Notarize an AT Protocol record on Ethereum
- */
-async notarizeRecord(recordURI: string): Promise<NotarizationResult> {
-  if (!this.config.schemaUID) {
-    throw new Error('Schema UID not set. Run initializeSchema() first.');
-  }
+  /**
+   * Notarize an AT Protocol record on Ethereum
+   */
+  async notarizeRecord(recordURI: string): Promise<NotarizationResult> {
+    if (!this.config.schemaUID) {
+      throw new Error('Schema UID not set. Run initializeSchema() first.');
+    }
 
-  // Parse URI
-  const { collection } = parseRecordURI(recordURI);
+    // Parse URI
+    const { collection } = parseRecordURI(recordURI);
 
-  // Fetch record
-  const record = await this.fetchRecord(recordURI);
+    // Fetch record directly from PDS
+    const { record, pds } = await this.fetchRecord(recordURI);
 
-  // Generate content hash
-  const contentHash = hashContent(record.value);
+    // Generate content hash
+    const contentHash = hashContent(record.value);
 
-  // Encode attestation data
-  const encodedData = encodeAttestationData({
-    recordURI,
-    contentHash: contentHash as Hash,
-    lexicon: collection,
-    timestamp: Math.floor(Date.now() / 1000),
-  });
+    // Get CID from the record response
+    const recordCID = record.cid;
 
-  // Create attestation request
-  const attestationRequest = {
-    schema: this.config.schemaUID as Hash,
-    data: {
-      recipient: zeroAddress,
-      expirationTime: 0n,
-      revocable: true,
-      refUID: '0x0000000000000000000000000000000000000000000000000000000000000000' as Hash,
-      data: encodedData,
-      value: 0n,
-    },
-  };
+    // Initialize SchemaEncoder with the schema string
+    const schemaEncoder = new SchemaEncoder(SCHEMA_STRING);
+    const encodedData = schemaEncoder.encodeData([
+      { name: "recordURI", value: recordURI, type: "string" },
+      { name: "cid", value: recordCID, type: "string" },
+      { name: "contentHash", value: contentHash, type: "bytes32" },
+      { name: "pds", value: pds, type: "string" },
+      { name: "timestamp", value: Math.floor(Date.now() / 1000), type: "uint256" }
+    ]);
 
-  // First simulate to get the return value (UID)
-  const { result: uid } = await this.publicClient.simulateContract({
-    address: this.config.easContractAddress,
-    abi: EAS_ABI,
-    functionName: 'attest',
-    args: [attestationRequest],
-    account: this.account,
-  });
+    const transaction = await this.eas.attest({
+      schema: this.config.schemaUID,
+      data: {
+        recipient: ethers.ZeroAddress,
+        expirationTime: NO_EXPIRATION,
+        revocable: false,
+        data: encodedData,
+      },
+    });
 
-  // Then submit the actual transaction
-  const hash = await this.walletClient.writeContract({
-    address: this.config.easContractAddress,
-    abi: EAS_ABI,
-    functionName: 'attest',
-    args: [attestationRequest],
-  });
+    const newAttestationUID = await transaction.wait();
 
-  // Wait for transaction
-  await this.publicClient.waitForTransactionReceipt({ hash });
+    return {
+      attestationUID: newAttestationUID,
+      recordURI,
+      cid: recordCID,
+      contentHash,
+      pds,
+      lexicon: collection,
+      transactionHash: transaction.tx?.hash,
+      explorerURL: getExplorerURL(newAttestationUID, this.network),
+    };
+  }
 
-  // Use the UID from simulation
-  const attestationUID = uid;
-
-  return {
-    attestationUID,
-    recordURI,
-    contentHash,
-    lexicon: collection,
-    transactionHash: hash,
-    explorerURL: getExplorerURL(attestationUID, this.network),
-  };
-}
 
   /**
    * Verify an attestation
    */
   async verifyAttestation(attestationUID: string): Promise<AttestationData> {
-    // Read attestation from contract
-    const attestation = await this.publicClient.readContract({
-      address: this.config.easContractAddress,
-      abi: EAS_ABI,
-      functionName: 'getAttestation',
-      args: [attestationUID as Hash],
-    });
+    const attestation = await this.eas.getAttestation(attestationUID);
 
-    // Check if attestation exists
-    if (attestation.uid === '0x0000000000000000000000000000000000000000000000000000000000000000') {
+    if (!attestation || attestation.uid === '0x0000000000000000000000000000000000000000000000000000000000000000') {
       throw new Error('Attestation not found');
     }
 
     // Decode attestation data
-    const decodedData = decodeAttestationData(attestation.data as Hash);
+    const schemaEncoder = new SchemaEncoder(SCHEMA_STRING);
+    const decodedData = schemaEncoder.decodeData(attestation.data);
+
+    const recordURI = decodedData.find(d => d.name === 'recordURI')?.value.value as string;
+    const cid = decodedData.find(d => d.name === 'cid')?.value.value as string;
+    const contentHash = decodedData.find(d => d.name === 'contentHash')?.value.value as string;
+    const pds = decodedData.find(d => d.name === 'pds')?.value.value as string;
+    const timestamp = Number(decodedData.find(d => d.name === 'timestamp')?.value.value);
+
+    // Parse lexicon from recordURI (since it's not in schema)
+    const { collection: lexicon } = parseRecordURI(recordURI);
 
     return {
       uid: attestationUID,
-      recordURI: decodedData.recordURI,
-      contentHash: decodedData.contentHash,
-      lexicon: decodedData.lexicon,
-      timestamp: decodedData.timestamp,
+      recordURI,
+      cid,
+      contentHash,
+      pds,
+      lexicon,
+      timestamp,
       attester: attestation.attester,
       revoked: attestation.revocationTime > 0n,
       explorerURL: getExplorerURL(attestationUID, this.network),
     };
   }
+
 
   /**
    * Compare attestation with current record state
···
     currentHash?: string;
   }> {
     try {
-      const record = await this.fetchRecord(attestationData.recordURI);
+      // fetchRecord now returns { record, pds }, so we need to destructure
+      const { record } = await this.fetchRecord(attestationData.recordURI);
       const currentHash = hashContent(record.value);
       
       return {
···
   /**
    * Get signer address
    */
-  getAddress(): Address {
-    return this.account.address;
+  async getAddress(): Promise<string> {
+    return this.signer.getAddress();
   }
 }

src/lib/types.ts

···
 export interface NotarizationResult {
   attestationUID: string;
   recordURI: string;
+  cid: string;
   contentHash: string;
+  pds: string;
   lexicon: string;
   transactionHash: string;
   explorerURL: string;
···
 export interface AttestationData {
   uid: string;
   recordURI: string;
+  cid: string;
   contentHash: string;
+  pds: string;
   lexicon: string;
   timestamp: number;
   attester: string;