epistery 2.0.4 → 2.2.0

package/src/utils/Config.ts

@@ -1,23 +1,59 @@
 import fs from 'fs';
+import fsp from 'fs/promises';
 import { join } from 'path';
 import ini from 'ini';
+import { ethers } from 'ethers';
 
 /**
- * Epistery Config - Path-based configuration system
+ * Epistery Config — async path-based configuration store.
  *
- * Provides unified, filesystem-like config management:
+ * Filesystem-like config management, now async so the same interface can be
+ * served by a remote authority:
  * - setPath('/') → ~/.epistery/config.ini
  * - setPath('/domain') → ~/.epistery/domain/config.ini
  * - setPath('/.ssl/domain') → ~/.epistery/.ssl/domain/config.ini
  *
+ * `Config` is a thin facade that picks a backend at construction:
+ *   - if the local bootstrap ~/.epistery/config.ini has [authority] url=…,
+ *     or EPISTERY_CONFIG_URL is set → RemoteConfig (talks to epistery-authority)
+ *   - otherwise → LocalConfig (the filesystem store; unchanged semantics)
+ *
+ * Every IO method is async because a remote/HSM custodian cannot answer
+ * synchronously. `data` holds the snapshot from the last awaited load()/setPath().
+ *
  * Usage:
  *   const config = new Config('epistery');
- *   config.setPath('/wiki.rootz.global');
- *   config.load();
+ *   await config.setPath('/wiki.rootz.global');   // loads
  *   config.data.verified = true;
- *   config.save();
+ *   await config.save();
+ */
+export interface ConfigStore {
+  data: any;
+  getPath(): string;
+  setPath(path: string): Promise<void>;
+  load(): Promise<void>;
+  read(path: string): Promise<any>;
+  save(): Promise<void>;
+  readFile(filename: string): Promise<Buffer>;
+  writeFile(filename: string, data: string | Buffer): Promise<void>;
+  exists(): Promise<boolean>;
+  listPaths(): Promise<string[]>;
+}
+
+/** Normalize a path: leading slash, no trailing slash, lowercase. */
+function normalizePath(path: string): string {
+  path = path.trim();
+  if (!path.startsWith('/')) path = '/' + path;
+  if (path.length > 1 && path.endsWith('/')) path = path.slice(0, -1);
+  return path.toLowerCase();
+}
+
+/**
+ * LocalConfig — the filesystem backend under ~/.epistery. This is the original
+ * Config behavior, with all IO made async. It is also what the epistery-authority
+ * server mounts as its own storage backend (one implementation, not two).
  */
-export class Config {
+export class LocalConfig implements ConfigStore {
   public readonly rootName: string;
   public readonly homeDir: string;
   public readonly configDir: string;
@@ -36,151 +72,313 @@ export class Config {
     this.currentDir = this.configDir;
     this.currentFile = join(this.configDir, 'config.ini');
 
-    // Initialize root config if it doesn't exist
+    // Bootstrap is synchronous: seed the root config so the very first run has
+    // somewhere to read the authority URL from. Only this seed stays sync; all
+    // subsequent IO is async.
     if (!fs.existsSync(this.currentFile)) {
-      this.initialize();
+      this.initializeSync();
     }
   }
 
-  /**
-   * Set current working path and load config (like cd)
-   * Examples: '/', 'domain', '/domain', '/.ssl/domain'
-   * Leading slash is optional and will be added if not present
-   * Automatically loads the config at the specified path
-   */
-  public setPath(path: string): void {
-    // Normalize path: ensure leading slash, remove trailing slash, lowercase
-    path = path.trim();
-    if (!path.startsWith('/')) path = '/' + path;
-    if (path.length > 1 && path.endsWith('/')) path = path.slice(0, -1);
-    path = path.toLowerCase();
+  private initializeSync(): void {
+    if (!fs.existsSync(this.currentDir)) {
+      fs.mkdirSync(this.currentDir, { recursive: true });
+    }
+    const defaultContent = this.currentPath === '/' ? defaultIni : '';
+    fs.writeFileSync(this.currentFile, defaultContent);
+    this.data = ini.decode(defaultContent);
+  }
+
+  public getPath(): string {
+    return this.currentPath;
+  }
 
+  public async setPath(path: string): Promise<void> {
+    path = normalizePath(path);
     this.currentPath = path;
 
-    // Calculate directory and file paths
     if (path === '/') {
       this.currentDir = this.configDir;
       this.currentFile = join(this.configDir, 'config.ini');
     } else {
-      this.currentDir = join(this.configDir, path.slice(1)); // Remove leading /
+      this.currentDir = join(this.configDir, path.slice(1));
       this.currentFile = join(this.currentDir, 'config.ini');
     }
 
-    // Automatically load the config at this path
-    this.load();
+    await this.load();
   }
 
-  /**
-   * Get current path
-   */
-  public getPath(): string {
-    return this.currentPath;
+  public async load(): Promise<void> {
+    try {
+      const fileData = await fsp.readFile(this.currentFile, 'utf8');
+      this.data = ini.decode(fileData);
+    } catch {
+      this.data = {};
+    }
   }
 
-  /**
-   * Initialize config at current path
-   */
-  private initialize(): void {
-    if (!fs.existsSync(this.currentDir)) {
-      fs.mkdirSync(this.currentDir, { recursive: true });
+  public async read(path: string): Promise<any> {
+    path = normalizePath(path);
+    const configFile = path === '/'
+      ? join(this.configDir, 'config.ini')
+      : join(this.configDir, path.slice(1), 'config.ini');
+    try {
+      const fileData = await fsp.readFile(configFile, 'utf8');
+      return ini.decode(fileData);
+    } catch {
+      return {};
     }
+  }
 
-    // Write default config for root, empty for paths
-    const defaultContent = this.currentPath === '/' ? defaultIni : '';
-    fs.writeFileSync(this.currentFile, defaultContent);
-    this.data = ini.decode(defaultContent);
+  public async save(): Promise<void> {
+    await fsp.mkdir(this.currentDir, { recursive: true });
+    await fsp.writeFile(this.currentFile, ini.stringify(this.data));
   }
 
-  /**
-   * Load config from current path
-   */
-  public load(): void {
-    if (!fs.existsSync(this.currentFile)) {
-      this.data = {};
-      return;
-    }
+  public async readFile(filename: string): Promise<Buffer> {
+    return fsp.readFile(join(this.currentDir, filename));
+  }
 
-    const fileData = fs.readFileSync(this.currentFile, 'utf8');
-    this.data = ini.decode(fileData);
+  public async writeFile(filename: string, data: string | Buffer): Promise<void> {
+    await fsp.mkdir(this.currentDir, { recursive: true });
+    await fsp.writeFile(join(this.currentDir, filename), data);
   }
 
-  /**
-   * Read config from arbitrary path without changing current path
-   * @param path Path to read from (e.g., '/', '/domain')
-   * @returns Parsed config data from that path
-   */
-  public read(path: string): any {
-    // Normalize path
-    path = path.trim();
-    if (!path.startsWith('/')) path = '/' + path;
-    if (path.length > 1 && path.endsWith('/')) path = path.slice(0, -1);
-    path = path.toLowerCase();
-
-    // Calculate file location
-    let configFile: string;
-    if (path === '/') {
-      configFile = join(this.configDir, 'config.ini');
-    } else {
-      configFile = join(this.configDir, path.slice(1), 'config.ini');
+  public async exists(): Promise<boolean> {
+    try {
+      await fsp.access(this.currentFile);
+      return true;
+    } catch {
+      return false;
     }
+  }
 
-    // Read and parse
-    if (!fs.existsSync(configFile)) {
-      return {};
+  public async listPaths(): Promise<string[]> {
+    try {
+      const entries = await fsp.readdir(this.currentDir, { withFileTypes: true });
+      return entries.filter(e => e.isDirectory()).map(e => e.name);
+    } catch {
+      return [];
     }
+  }
+}
+
+/**
+ * RemoteConfig — HTTP client to an epistery-authority server. Implements the
+ * same ConfigStore interface; the authority mounts a LocalConfig behind it.
+ *
+ * Auth is the rivet key-exchange: the machine signs a challenge with its
+ * device key, and the authority issues a bearer token (see epistery-authority
+ * lib/auth.mjs). In Phase 1 config data (including the wallet mnemonic) is
+ * still served; Phase 2 splits public from secret and adds /sign/*.
+ */
+export class RemoteConfig implements ConfigStore {
+  public data: any = {};
+  private currentPath: string = '/';
+  private token: string | null = null;
+
+  // Optional per-role subtree on the authority. When set (e.g. '/relay'), every
+  // path the client uses is remapped under it: the client's '/' → authority
+  // '/relay', '/relay.epistery.com' → '/relay/relay.epistery.com'. This lets a
+  // role (and a pool of its instances) share one config + cert subtree without
+  // colliding with other roles on the authority's root. Empty = no remap.
+  private readonly basePath: string;
 
-    const fileData = fs.readFileSync(configFile, 'utf8');
-    return ini.decode(fileData);
+  constructor(
+    private readonly baseUrl: string,
+    private readonly machineAddress: string,
+    private readonly signChallenge: (message: string) => Promise<string>,
+    basePath: string = '',
+  ) {
+    this.baseUrl = baseUrl.replace(/\/+$/, '');
+    this.basePath = (!basePath || basePath === '/') ? '' : normalizePath(basePath);
   }
 
-  /**
-   * Save config to current path
-   */
-  public save(): void {
-    if (!fs.existsSync(this.currentDir)) {
-      fs.mkdirSync(this.currentDir, { recursive: true });
+  public getPath(): string {
+    return this.currentPath;     // the client's logical path (unprefixed)
+  }
+
+  /** Map a client path into the authority's namespace under basePath. */
+  private prefixed(path: string): string {
+    const p = normalizePath(path);
+    if (!this.basePath) return p;
+    return p === '/' ? this.basePath : this.basePath + p;
+  }
+
+  private async authenticate(): Promise<void> {
+    const fetch = (globalThis as any).fetch;
+    const cRes = await fetch(`${this.baseUrl}/auth/challenge`, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ machineAddress: this.machineAddress }),
+    });
+    if (!cRes.ok) throw new Error(`authority challenge failed: ${cRes.status}`);
+    const { challenge } = await cRes.json();
+
+    const message = `Epistery Key Exchange - ${this.machineAddress} - ${challenge}`;
+    const signature = await this.signChallenge(message);
+
+    const vRes = await fetch(`${this.baseUrl}/auth/verify`, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ machineAddress: this.machineAddress, message, signature }),
+    });
+    if (!vRes.ok) throw new Error(`authority verify failed: ${vRes.status}`);
+    this.token = (await vRes.json()).token;
+  }
+
+  private async authedFetch(pathAndQuery: string, init: any = {}): Promise<any> {
+    const fetch = (globalThis as any).fetch;
+    if (!this.token) await this.authenticate();
+    const withAuth = () => ({ ...init, headers: { ...(init.headers || {}), authorization: `Bearer ${this.token}` } });
+    let res = await fetch(this.baseUrl + pathAndQuery, withAuth());
+    if (res.status === 401) {
+      this.token = null;            // expired — re-auth once
+      await this.authenticate();
+      res = await fetch(this.baseUrl + pathAndQuery, withAuth());
     }
+    return res;
+  }
 
-    const text = ini.stringify(this.data);
-    fs.writeFileSync(this.currentFile, text);
+  public async setPath(path: string): Promise<void> {
+    this.currentPath = normalizePath(path);
+    await this.load();
   }
 
-  /**
-   * Read file from current path directory
-   */
-  public readFile(filename: string): Buffer {
-    return fs.readFileSync(join(this.currentDir, filename));
+  public async load(): Promise<void> {
+    this.data = await this.read(this.currentPath);
   }
 
-  /**
-   * Write file to current path directory
-   */
-  public writeFile(filename: string, data: string | Buffer): void {
-    if (!fs.existsSync(this.currentDir)) {
-      fs.mkdirSync(this.currentDir, { recursive: true });
+  public async read(path: string): Promise<any> {
+    const p = this.prefixed(path);
+    const res = await this.authedFetch(`/config${p === '/' ? '/' : p}`);
+    if (!res.ok) return {};
+    return (await res.json()).data || {};
+  }
+
+  public async save(): Promise<void> {
+    const p = this.prefixed(this.currentPath);
+    const res = await this.authedFetch(`/config${p === '/' ? '/' : p}`, {
+      method: 'PUT',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ data: this.data }),
+    });
+    if (!res.ok) throw new Error(`authority save failed: ${res.status}`);
+  }
+
+  private filePrefix(): string {
+    const p = this.prefixed(this.currentPath);
+    return p === '/' ? '' : p;
+  }
+
+  public async readFile(filename: string): Promise<Buffer> {
+    const res = await this.authedFetch(`/file${this.filePrefix()}/${filename}`);
+    if (!res.ok) throw new Error(`authority file read failed: ${res.status}`);
+    return Buffer.from(await res.arrayBuffer());
+  }
+
+  public async writeFile(filename: string, data: string | Buffer): Promise<void> {
+    const res = await this.authedFetch(`/file${this.filePrefix()}/${filename}`, {
+      method: 'PUT',
+      headers: { 'content-type': 'application/octet-stream' },
+      body: data,
+    });
+    if (!res.ok) throw new Error(`authority file write failed: ${res.status}`);
+  }
+
+  public async exists(): Promise<boolean> {
+    const data = await this.read(this.currentPath);
+    return !!data && Object.keys(data).length > 0;
+  }
+
+  public async listPaths(): Promise<string[]> {
+    const p = this.prefixed(this.currentPath);
+    const res = await this.authedFetch(`/paths${p === '/' ? '/' : p}`);
+    if (!res.ok) return [];
+    return (await res.json()).paths || [];
+  }
+}
+
+/**
+ * Config — the public facade. `new Config()` selects the backend synchronously
+ * (reading only the local bootstrap), then delegates every async operation.
+ * Existing call sites change only by adding `await`.
+ */
+export class Config implements ConfigStore {
+  private readonly backend: ConfigStore;
+  private readonly local: LocalConfig;
+
+  constructor(rootName: string = 'epistery') {
+    this.local = new LocalConfig(rootName);
+    const authorityUrl = Config.resolveAuthorityUrl(rootName);
+    if (authorityUrl) {
+      const { machineAddress, sign } = Config.machineSigner(rootName);
+      // Per-role subtree: this host's '/' maps under it on the authority, so a
+      // pool of like role instances shares one config + cert subtree.
+      const root = process.env.EPISTERY_CONFIG_ROOT
+        || Config.readBootstrap(rootName)?.authority?.root || '';
+      this.backend = new RemoteConfig(authorityUrl, machineAddress, sign, root);
+    } else {
+      this.backend = this.local;
     }
-    fs.writeFileSync(join(this.currentDir, filename), data);
   }
 
-  /**
-   * Check if config exists at current path
-   */
-  public exists(): boolean {
-    return fs.existsSync(this.currentFile);
+  /** Read the local bootstrap config.ini synchronously (authority selection only). */
+  private static readBootstrap(rootName: string): any {
+    const homeDir = (process.platform === 'win32' ? process.env.USERPROFILE : process.env.HOME) || '';
+    const file = join(homeDir, '.' + rootName, 'config.ini');
+    try {
+      return ini.decode(fs.readFileSync(file, 'utf8'));
+    } catch {
+      return {};
+    }
+  }
+
+  private static resolveAuthorityUrl(rootName: string): string | null {
+    if (process.env.EPISTERY_CONFIG_URL) return process.env.EPISTERY_CONFIG_URL;
+    const boot = Config.readBootstrap(rootName);
+    return boot?.authority?.url || null;
   }
 
   /**
-   * List all subdirectories at current path
+   * Build the machine signer used to authenticate to the authority. The machine
+   * rivet key lives in the local bootstrap [authority] section (Phase 1). A
+   * future TPM-backed key replaces this without changing the call site.
    */
-  public listPaths(): string[] {
-    if (!fs.existsSync(this.currentDir)) {
-      return [];
+  private static machineSigner(rootName: string): { machineAddress: string; sign: (m: string) => Promise<string> } {
+    const boot = Config.readBootstrap(rootName);
+    const a = boot?.authority || {};
+    let wallet: ethers.Wallet;
+    if (a.machineMnemonic) {
+      wallet = ethers.Wallet.fromMnemonic(a.machineMnemonic);
+    } else if (a.machineKey) {
+      wallet = new ethers.Wallet(a.machineKey);
+    } else {
+      throw new Error(
+        'Config: [authority] url is set but no machine credential ([authority] machineMnemonic or machineKey) is configured to authenticate to it.',
+      );
     }
-
-    return fs.readdirSync(this.currentDir, { withFileTypes: true })
-      .filter(dirent => dirent.isDirectory())
-      .map(dirent => dirent.name);
+    return { machineAddress: wallet.address, sign: (m: string) => wallet.signMessage(m) };
   }
+
+  // Local-machine facts (always the bootstrap LocalConfig, even in remote mode):
+  // these are filesystem paths some callers need (e.g. CliWallet session dir).
+  public get rootName(): string { return this.local.rootName; }
+  public get homeDir(): string { return this.local.homeDir; }
+  public get configDir(): string { return this.local.configDir; }
+
+  public get data(): any { return this.backend.data; }
+  public set data(v: any) { this.backend.data = v; }
+
+  public getPath(): string { return this.backend.getPath(); }
+  public setPath(path: string): Promise<void> { return this.backend.setPath(path); }
+  public load(): Promise<void> { return this.backend.load(); }
+  public read(path: string): Promise<any> { return this.backend.read(path); }
+  public save(): Promise<void> { return this.backend.save(); }
+  public readFile(filename: string): Promise<Buffer> { return this.backend.readFile(filename); }
+  public writeFile(filename: string, data: string | Buffer): Promise<void> { return this.backend.writeFile(filename, data); }
+  public exists(): Promise<boolean> { return this.backend.exists(); }
+  public listPaths(): Promise<string[]> { return this.backend.listPaths(); }
 }
 
 const defaultIni =
@@ -224,4 +422,13 @@ nativeCurrencyDecimals=18
 ;   minPriorityFeeGwei=25         ; Polygon RPC floor (don't lower)
 ;   [default.rpc.81.policy]
 ;   maxGasPriceGwei=1000           ; legacy-chain analogue (JOC)
-`
+
+; Shared Configuration Authority (optional). When set, Config reads/writes
+; through the epistery-authority server instead of the local filesystem, so
+; this host becomes a stateless pool member. EPISTERY_CONFIG_URL overrides url.
+;   [authority]
+;   url=https://epistery-authority-1.internal:4500
+;   machineMnemonic=...            ; this machine's rivet (or machineKey=0x…)
+;   root=/relay                    ; optional: this role's subtree on the authority
+;                                  ; (a pool of like instances shares it). EPISTERY_CONFIG_ROOT overrides.
+`;

package/src/utils/Utils.ts

@@ -11,7 +11,7 @@ export class Utils {
   // across concurrent requests for different domains on a multi-tenant host.
   private static walletCache: Map<string, ethers.Wallet> = new Map();
 
-  public static InitServerWallet(domain: string = 'localhost'): ethers.Wallet | null {
+  public static async InitServerWallet(domain: string = 'localhost'): Promise<ethers.Wallet | null> {
     // Fast path: return cached wallet for this domain. Avoids both the
     // wallet-rebuild cost and the static config setPath mutation.
     const cached = this.walletCache.get(domain);
@@ -25,7 +25,7 @@ export class Utils {
       }
 
       // Load domain config
-      this.config.setPath(domain);
+      await this.config.setPath(domain);
 
       const domainConfig = this.config.data.domain ? this.config.data : {domain: domain};
 
@@ -41,10 +41,10 @@ export class Utils {
       // "provider=undefined", and which on reload becomes a truthy
       // string that bypasses the `||` fallback below at chainFor).
       if (!domainConfig.provider) {
-        this.config.setPath('/');
+        await this.config.setPath('/');
         domainConfig.provider =
           this.config.data.default?.provider ?? this.config.data.provider;
-        this.config.setPath(domain); // Switch back to domain
+        await this.config.setPath(domain); // Switch back to domain
       }
 
       if (!domainConfig.wallet) {
@@ -69,7 +69,7 @@ export class Utils {
         }
 
         this.config.data = domainConfig;
-        this.config.save();
+        await this.config.save();
 
         console.log(`[debug] Created new wallet for domain: ${domain}`);
         console.log(`[debug] Wallet address: ${wallet.address}`);
@@ -98,6 +98,17 @@ export class Utils {
     return this.serverWallet;
   }
 
+  /**
+   * Synchronous accessor for a domain's already-initialized wallet, read from
+   * the per-domain cache. Returns null if InitServerWallet(domain) has not been
+   * awaited yet. This lets the synchronous `get signer()` getter survive the
+   * async migration: setDomain() awaits InitServerWallet to warm the cache, and
+   * the getter reads it here without re-entering async config IO.
+   */
+  public static GetServerWalletFor(domain: string): ethers.Wallet | null {
+    return this.walletCache.get(domain) || null;
+  }
+
   public static GetConfig(): Config {
     if (!this.config) {
       this.config = new Config();
@@ -105,13 +116,12 @@ export class Utils {
     return this.config;
   }
 
-  public static GetDomainInfo(domain: string = 'localhost'): DomainConfig {
+  public static async GetDomainInfo(domain: string = 'localhost'): Promise<DomainConfig> {
     if (!this.config) {
       this.config = new Config();
     }
 
-    this.config.setPath(`/${domain}`);
-    this.config.load();
+    await this.config.setPath(`/${domain}`);
 
     if (!this.config.data.domain)
       return {domain:domain};
@@ -126,7 +136,7 @@ export class Utils {
     // read epistery.domain.provider.rpc (e.g. connect's on-chain contract
     // verification) get no RPC. read('/') doesn't move the current path.
     if (!domainConfig.provider) {
-      const rootData = this.config.read('/');
+      const rootData = await this.config.read('/');
       domainConfig.provider = rootData.default?.provider ?? rootData.provider;
     }
 

package/test/config/.epistery/127.0.0.1/config.ini

@@ -0,0 +1,15 @@
+domain=127.0.0.1
+
+[provider]
+chainId=80002
+name=Polygon Amoy Testnet
+rpc=https://rpc-amoy.polygon.technology
+nativeCurrencyName=POL
+nativeCurrencySymbol=POL
+nativeCurrencyDecimals=18
+
+[wallet]
+address=0x94C8407888499483CB6795cd5155801B9e767515
+mnemonic=meadow chimney grain search thrive away visual grace wear powder giant profit
+publicKey=0x04098c8c61f007b937dc9f5ec63ec41857b4b50ece763d8c1501876f3ae33b8758d7cdf0e4cb6cf44f715b7e8395b9ee81b0ff258816a1b6ce9ea76e91626962eb
+privateKey=0x4f2bd152b2c3b08472ed4e61297058d8df367bd96e66ee76fed6ad778de92aaa

package/test/config/.epistery/config.ini

@@ -0,0 +1,14 @@
+[profile]
+name=Test Profile
+email=test@epistery.test
+
+[default.provider]
+chainId=80002
+name=Polygon Amoy Testnet
+rpc=https://rpc-amoy.polygon.technology
+nativeCurrencyName=POL
+nativeCurrencySymbol=POL
+nativeCurrencyDecimals=18
+
+[cli]
+default_domain=localhost

package/test/config/.epistery/localhost/config.ini

@@ -0,0 +1,16 @@
+domain=localhost
+pending=true
+
+[wallet]
+address=0x5277286b5821D1bF5c2395F38c3250A5B0F14da3
+mnemonic=attack sweet hint arctic skull vessel refuse mountain tiny kind feature amazing
+publicKey=0x041de8ef7ae49c387ed8f8c138f33901acefdd63e03300dbd205bd407efba3b95002b5337ce4437924b52c9581cf7bda21eb6df5f0d3e17fbd99ccddfefc63f0d8
+privateKey=0x91806b336879df60435ab8f95673bbdd7b24d47dec5ac35c10098934f214049d
+
+[provider]
+name=Polygon Amoy Testnet
+chainId=80002
+rpc=https://rpc-amoy.polygon.technology
+nativeCurrencySymbol=POL
+nativeCurrencyName=POL
+nativeCurrencyDecimals=18

package/test/config/.epistery/no-pending-claim.local/config.ini

@@ -0,0 +1,15 @@
+domain=no-pending-claim.local
+
+[provider]
+chainId=80002
+name=Polygon Amoy Testnet
+rpc=https://rpc-amoy.polygon.technology
+nativeCurrencyName=POL
+nativeCurrencySymbol=POL
+nativeCurrencyDecimals=18
+
+[wallet]
+address=0xaDBD5bBE73B80430E047A3496d277B05191c45CA
+mnemonic=devote link lens finger february close soda harbor urge chunk zoo knife
+publicKey=0x042c874d737d4c4620bc03a255ebf7733f369c603e8bdf8cbcddbdd0042d257e06f684374b1d4502d2db202ced4dcaa7139c9ec92c93deafa2ca718265a9ad8580
+privateKey=0x5b02e2b6f91e742d52d4d75b91be1cea416561fb67a4873c2842ba0b2a023dfd

package/test/config/.epistery/test-claim-1782325887560.local/config.ini

@@ -0,0 +1,20 @@
+domain=test-claim-1782325887560.local
+pending=true
+challenge_token=3027fd6c76df13ea5c5a22c8e89b496cf541e6a55484fb67dc20df4c1b033ed6
+challenge_address=0xdcb8454e5ce6b911dba93c11ad530c61d2520d8e
+challenge_created=2026-06-24T18:31:27.608Z
+challenge_requester_ip=::ffff:127.0.0.1
+
+[provider]
+name=Polygon Amoy Testnet
+chainId=80002
+rpc=https://rpc-amoy.polygon.technology
+nativeCurrencySymbol=POL
+nativeCurrencyName=POL
+nativeCurrencyDecimals=18
+
+[wallet]
+address=0xcB676926b57659261Cb4C8bA765E895E9A61363B
+mnemonic=clinic tragic regular leave sunset expect manage rally street derive swap rapid
+publicKey=0x047389a40eb30c1da9f0fe88d4e05df15f4940022f5c1b3928b4de08f205274ba220d19811d2d8ab5dac45e0c0ff2caf6dad1db8e834354df65da2973e306fdbc8
+privateKey=0xa26ab628421a96202f49516d236c15144cc9825c636146ddb3091f649e51501b