more updates

.gitignore

···
 node_modules
 bun.lock
 dist
-coverage
+coverage
+.atnotary*

README.md

···
 - **Infrastructure** - explorers, indexers, and tooling already exist
 - **Multi-chain** - works on Ethereum, Base, Optimism, Arbitrum
 
-**Why AT Protocol:**
-Unlike Twitter, AT Protocol is federated and open. Users own their data, can switch servers, and the protocol is public. This makes it possible to build open infrastructure for accountability that isn't controlled by any company.
-
-**Principles:**
-- Transparency without judgment - just preserves facts, doesn't label "good" or "bad"
-- Decentralized - fetches directly from user's PDS, not centralized APIs
-- User choice - opt-in system, you choose what to notarize
-- Open infrastructure - anyone can verify, build on, or run their own instance
-
-Think of it as combining two open protocols: **AT Protocol** (decentralized social) + **EAS** (decentralized attestations) = transparent, accountable social web.
-
 ## What Gets Attested
 
 - `recordURI` - Full AT Protocol URI
 - `cid` - AT Protocol's content identifier
-- `contentHash` - SHA-256 hash
+- `contentHash` - DAG-CBOR hash
 - `pds` - Personal Data Server URL
 - `timestamp` - When attested
 
···
 
 ## Setup
 
-1. **Create `.env` file:**
+1. **Create config file:**
 
 ```bash
-PRIVATE_KEY="0x..."
-# SCHEMA_UID is optional - default schemas are provided
+atnotary config
+```
+
+2. **Edit `.atnotary.yaml`:**
+
+```yaml
+privateKey: "0x..."       # private key for writing
+network: base-sepolia     # default network
 ```
 
-2. **Get testnet ETH:**
+3. **Get testnet ETH:**
    - Sepolia: https://sepoliafaucet.com/
    - Base Sepolia: https://bridge.base.org/
 
···
 atnotary init --network sepolia
 ```
 
-Then add the `SCHEMA_UID` to your `.env` file.
+Then add the `schemaUID` to your `.atnotary.yaml` file.
 
 ## Usage
 
···
 import { ATProtocolNotary } from 'atnotary';
 
 const notary = new ATProtocolNotary({
-  privateKey: process.env.PRIVATE_KEY!,
-  schemaUID: process.env.SCHEMA_UID!,
+  privateKey: "0x...", // optional, just for writing
 }, 'sepolia');
 
 const result = await notary.notarizeRecord('at://...');
···
 
 ## License
 
-MIT
-
+MIT

package.json

···
     "@atproto/api": "^0.12.29",
     "@ethereum-attestation-service/eas-sdk": "^2.9.0",
     "@ipld/dag-cbor": "^9.2.5",
-    "ethers": "^6.15.0"
+    "ethers": "^6.15.0",
+    "js-yaml": "^4.1.0"
   },
   "devDependencies": {
+    "@types/js-yaml": "^4.0.9",
     "@types/node": "^20.19.21",
     "@vitest/coverage-v8": "^3.2.4",
     "chalk": "^5.6.2",
     "commander": "^11.1.0",
-    "dotenv": "^16.6.1",
     "ora": "^8.2.0",
     "tsx": "^4.20.6",
     "typescript": "^5.9.3",

pnpm-lock.yaml

···
       ethers:
         specifier: ^6.15.0
         version: 6.15.0
+      js-yaml:
+        specifier: ^4.1.0
+        version: 4.1.0
     devDependencies:
+      '@types/js-yaml':
+        specifier: ^4.0.9
+        version: 4.0.9
       '@types/node':
         specifier: ^20.19.21
         version: 20.19.21
···
       commander:
         specifier: ^11.1.0
         version: 11.1.0
-      dotenv:
-        specifier: ^16.6.1
-        version: 16.6.1
       ora:
         specifier: ^8.2.0
         version: 8.2.0
···
   '@types/estree@1.0.8':
     resolution: {integrity: sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==}
 
+  '@types/js-yaml@4.0.9':
+    resolution: {integrity: sha512-k4MGaQl5TGo/iipqb2UDG2UwjXziSWkh0uysQelTlJpX1qGlpUZYm8PnO4DxG1qBomtJUdYJ6qR6xdIah10JLg==}
+
   '@types/lru-cache@5.1.1':
     resolution: {integrity: sha512-ssE3Vlrys7sdIzs5LOxCzTVMsU7i9oa/IaW92wF32JFb3CVczqOkru2xspuKczHEbG3nvmPY7IFqVmGGHdNbYw==}
 
···
   diff@5.2.0:
     resolution: {integrity: sha512-uIFDxqpRZGZ6ThOk84hEfqWoHx2devRFvpTZcTHur85vImfaxUbTW9Ryh4CpCuDnToOP1CEtXKIgytHBPVff5A==}
     engines: {node: '>=0.3.1'}
-
-  dotenv@16.6.1:
-    resolution: {integrity: sha512-uBq4egWHTcTt33a72vpSG0z3HnPuIl6NqYcTrKEg2azoEyl2hpW0zqlxysq2pK9HlDIHyHyakeYaYnSAwd8bow==}
-    engines: {node: '>=12'}
 
   dunder-proto@1.0.1:
     resolution: {integrity: sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==}
···
 
   '@types/estree@1.0.8': {}
 
+  '@types/js-yaml@4.0.9': {}
+
   '@types/lru-cache@5.1.1': {}
 
   '@types/ms@2.1.0': {}
···
   depd@2.0.0: {}
 
   diff@5.2.0: {}
-
-  dotenv@16.6.1: {}
 
   dunder-proto@1.0.1:
     dependencies:

src/cli.ts

···
 import { Command } from 'commander';
 import chalk from 'chalk';
 import ora from 'ora';
-import * as dotenv from 'dotenv';
+import * as path from 'path';
+import * as os from 'os';
+import * as fs from 'node:fs';
 import { ATProtocolNotary } from './lib/index.js';
-
-dotenv.config();
+import { loadConfig, getSchemaUID, createConfigTemplate } from './lib/config.js';
 
 const program = new Command();
 
 program
   .name('atnotary')
   .description('Notarize AT Protocol records on Ethereum using EAS')
-  .version('0.1.0');
+  .version('0.1.0')
+  .option('-c, --config <path>', 'Path to config file');
+
+// Config command
+program
+  .command('config')
+  .description('Create config template')
+  .option('-g, --global', 'Create in home directory')
+  .option('-f, --force', 'Overwrite existing config file')
+  .action((options) => {
+    const configPath = options.global
+      ? path.join(os.homedir(), '.atnotary.yaml')
+      : path.join(process.cwd(), '.atnotary.yaml');
+    
+    // Check if file exists
+    if (fs.existsSync(configPath) && !options.force) {
+      console.log(chalk.yellow(`\n⚠️  Config file already exists: ${configPath}`));
+      console.log(chalk.gray('Use --force to overwrite\n'));
+      process.exit(1);
+    }
+    
+    createConfigTemplate(configPath);
+    console.log(chalk.green(`\n✅ Config template created: ${configPath}`));
+    console.log(chalk.yellow('\nEdit the file and add your private key and schema UIDs.\n'));
+  });
 
 // Initialize command
 program
···
   .option('-n, --network <network>', 'Network to use', 'sepolia')
   .action(async (options) => {
     try {
+      const config = loadConfig(program.opts().config);
+      
       console.log(chalk.blue('🔧 Initializing EAS Schema'));
       console.log(chalk.gray(`Network: ${options.network}\n`));
       
       const spinner = ora(`Connecting to ${options.network}...`).start();
       
       const notary = new ATProtocolNotary({
-        privateKey: process.env.PRIVATE_KEY!,
+        privateKey: config.privateKey,
       }, options.network);
       
       const address = await notary.getAddress();
       spinner.succeed(`Connected to ${options.network}: ${address}`);
+      console.log(chalk.blue('Account:'), chalk.cyan(address));
       
       spinner.start(`Creating schema on EAS (${options.network})...`);
       const schemaUID = await notary.initializeSchema();
···
       spinner.succeed('Schema created!');
       
       console.log(chalk.green('\n✅ Schema UID:'), chalk.cyan(schemaUID));
-      console.log(chalk.yellow('\n⚠️  Add this to your .env file:'));
-      console.log(chalk.gray(`SCHEMA_UID="${schemaUID}"\n`));
+      console.log(chalk.yellow('\n⚠️  Add this to your .atnotary.json:'));
+      console.log(chalk.gray(`\n"networks": {\n  "${options.network}": {\n    "schemaUID": "${schemaUID}"\n  }\n}\n`));
       
     } catch (error: any) {
       console.error(chalk.red('Error:'), error.message);
···
 program
   .command('notarize <recordURI>')
   .description('Notarize an AT Protocol record')
-  .option('-n, --network <network>', 'Network to use', 'sepolia')
+  .option('-n, --network <network>', 'Network to use')
   .action(async (recordURI: string, options) => {
     try {
+      const config = loadConfig(program.opts().config);
+      const network = options.network || config.network || 'sepolia';
+      
       console.log(chalk.blue('🔐 AT Protocol Notary'));
-      console.log(chalk.gray(`Network: ${options.network}\n`));
+      console.log(chalk.gray(`Network: ${network}\n`));
       
       const spinner = ora('Initializing...').start();
       
       const notary = new ATProtocolNotary({
-        privateKey: process.env.PRIVATE_KEY!,
-        schemaUID: process.env.SCHEMA_UID,
-      }, options.network);
+        privateKey: config.privateKey,
+        schemaUID: getSchemaUID(config, network),
+      }, network);
       
-      spinner.succeed('Initialized');
+      // Show account info
+      const address = await notary.getAddress();
+      spinner.succeed(`Initialized with account: ${chalk.cyan(address)}`);
       
       spinner.start('Resolving DID to PDS...');
       const { record, pds } = await notary.fetchRecord(recordURI);
···
       console.log(chalk.gray('\nRecord preview:'));
       console.log(chalk.gray(JSON.stringify(record.value, null, 2).substring(0, 200) + '...\n'));
       
-      spinner.start(`Creating attestation on ${options.network}...`);
+      spinner.start(`Creating attestation on ${network}...`);
       const result = await notary.notarizeRecord(recordURI);
       spinner.succeed('Attestation created!');
       
       console.log(chalk.green('\n✅ Notarization Complete!\n'));
-      console.log(chalk.blue('Network:'), chalk.gray(options.network));
+      console.log(chalk.blue('Network:'), chalk.gray(network));
+      console.log(chalk.blue('Attester:'), chalk.cyan(address));
       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.cyan(result.explorerURL + '\n'));
       
       console.log(chalk.yellow('🔍 Verify with:'));
-      console.log(chalk.gray(`atnotary verify ${result.attestationUID} --network ${options.network}\n`));
+      console.log(chalk.gray(`atnotary verify ${result.attestationUID} --network ${network}\n`));
       
     } catch (error: any) {
       console.error(chalk.red('Error:'), error.message);
       process.exit(1);
     }
   });
+
 
 // Verify command
 program
   .command('verify <attestationUID>')
   .description('Verify an attestation')
-  .option('-n, --network <network>', 'Network to use', 'sepolia')
-  .option('-c, --compare', 'Compare with current record state')
+  .option('-n, --network <network>', 'Network to use')
+  .option('--compare', 'Compare with current record state')
   .action(async (attestationUID: string, options) => {
     try {
+      const config = loadConfig(program.opts().config);
+      const network = options.network || config.network || 'sepolia';
+      
       console.log(chalk.blue('🔍 Verifying Attestation'));
-      console.log(chalk.gray(`Network: ${options.network}\n`));
+      console.log(chalk.gray(`Network: ${network}\n`));
       
-      const spinner = ora(`Fetching attestation from EAS (${options.network})...`).start();
+      const spinner = ora(`Fetching attestation from EAS (${network})...`).start();
       
       const notary = new ATProtocolNotary({
-        schemaUID: process.env.SCHEMA_UID,
-      }, options.network);
+        schemaUID: getSchemaUID(config, network),
+      }, network);
       
       const attestation = await notary.verifyAttestation(attestationUID);
       spinner.succeed('Attestation found');
       
       console.log(chalk.green('\n✅ Attestation Valid\n'));
-      console.log(chalk.blue('Network:'), chalk.gray(options.network));
+      console.log(chalk.blue('Network:'), chalk.gray(network));
       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('Timestamp:'), chalk.gray(new Date(attestation.timestamp * 1000).toISOString()));
       console.log(chalk.blue('Attester:'), chalk.gray(attestation.attester));
       
-      // Compare with current if requested
       if (options.compare) {
         console.log(chalk.yellow('\n🔄 Comparing with current record...'));
         
···
           if (!comparison.exists) {
             console.log(chalk.red('⚠ Record has been deleted'));
           } else {
-            // Check CID
             if (comparison.cidMatches) {
-              console.log(chalk.green('✓ CID matches (content identical via AT Protocol)'));
+              console.log(chalk.green('✓ CID matches (content identical)'));
             } 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}`));
+              console.log(chalk.gray(`  Attested: ${attestation.cid}`));
+              console.log(chalk.gray(`  Current:  ${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.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/config.ts

···
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import yaml from 'js-yaml';
+
+export interface Config {
+  privateKey?: string;
+  network?: string;
+  networks?: {
+    [network: string]: {
+      schemaUID?: string;
+      rpcUrl?: string;
+      easContractAddress?: string;
+      schemaRegistryAddress?: string;
+    };
+  };
+}
+
+/**
+ * Load config from multiple sources (priority order):
+ * 1. Custom config path (--config flag)
+ * 2. ./.atnotary.yaml (current directory)
+ * 3. ~/.atnotary.yaml (home directory)
+ * 4. .env file (fallback)
+ */
+export function loadConfig(customPath?: string): Config {
+  let config: Config = {};
+
+  // Try custom path first
+  if (customPath) {
+    if (fs.existsSync(customPath)) {
+      config = loadYamlConfig(customPath);
+      return config;
+    } else {
+      throw new Error(`Config file not found: ${customPath}`);
+    }
+  }
+
+  // Try current directory
+  const localConfig = path.join(process.cwd(), '.atnotary.yaml');
+  if (fs.existsSync(localConfig)) {
+    config = loadYamlConfig(localConfig);
+    return config;
+  }
+
+  // Try home directory
+  const homeConfig = path.join(os.homedir(), '.atnotary.yaml');
+  if (fs.existsSync(homeConfig)) {
+    config = loadYamlConfig(homeConfig);
+    return config;
+  }
+
+  return config;
+}
+
+function loadYamlConfig(filePath: string): Config {
+  try {
+    const fileContents = fs.readFileSync(filePath, 'utf8');
+    const config = yaml.load(fileContents) as Config;
+    return config;
+  } catch (error: any) {
+    throw new Error(`Failed to load config from ${filePath}: ${error.message}`);
+  }
+}
+
+/**
+ * Get schema UID for specific network
+ */
+export function getSchemaUID(config: Config, network: string): string | undefined {
+  return config.networks?.[network]?.schemaUID;
+}
+
+/**
+ * Create default config template
+ */
+export function createConfigTemplate(outputPath: string): void {
+  const template = `# atnotary configuration
+# Private key for signing transactions (required for notarization)
+privateKey: "0x..."
+
+# Default network (sepolia, base-sepolia, base)
+network: sepolia
+
+# Network-specific configuration
+networks:
+  sepolia:
+    schemaUID: "0x..."
+    # Optional: custom RPC URL
+    # rpcUrl: "https://..."
+    
+  base-sepolia:
+    schemaUID: "0x..."
+    # rpcUrl: "https://sepolia.base.org"
+    
+  base:
+    schemaUID: "0x..."
+    # rpcUrl: "https://mainnet.base.org"
+`;
+
+  fs.writeFileSync(outputPath, template, 'utf8');
+}

src/lib/notary.ts

···
 // Default schemas (deployed by atnotary maintainers)
 const DEFAULT_SCHEMAS = {
   'sepolia': '0x2a39517604107c79acbb962fe809795a87b7e47b8682fd9fbd3f62694fcca47c',
-  'base-sepolia': '0x...', // TODO: Deploy and add schema UID
+  'base-sepolia': '0x2a39517604107c79acbb962fe809795a87b7e47b8682fd9fbd3f62694fcca47c',
   'base': '0x...', // TODO: Deploy and add schema UID
 };
 
···
 export class ATProtocolNotary {
   private config: Required<NotaryConfig>;
   private provider: ethers.JsonRpcProvider;
-  private signer: ethers.Wallet;
+  private signer?: ethers.Wallet;
   private network: string;
   private chainConfig: typeof CHAIN_CONFIG[keyof typeof CHAIN_CONFIG];
   private eas: any;
-  private schemaRegistry: any;
+  private schemaRegistry?: any;
 
   constructor(config: NotaryConfig = {}, network: string = 'sepolia') {
     this.network = network;
···
     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);
-
-    console.log({ extracted: extractHashFromCID(cid), real: contentHash })
 
     // Parse lexicon from recordURI (since it's not in schema)
     const { collection: lexicon } = parseRecordURI(recordURI);