openttt 0.1.2 → 0.2.0

package/dist/http_client.d.ts

@@ -0,0 +1,98 @@
+/**
+ * TTTClient.httpOnly() — Zero-friction Proof of Time
+ * No ETH, no signer, no on-chain. Just verified time.
+ *
+ * Usage:
+ *   const client = TTTClient.httpOnly();
+ *   const pot = await client.generatePoT();
+ *   console.log(pot.timestamp, pot.confidence);
+ *
+ * Time sources: NIST, Apple, Google, Cloudflare HTTPS Date headers.
+ * HMAC-SHA256 signature — no ethers.js dependency required.
+ */
+import { ProofOfTime } from "./types";
+export interface HttpPoT {
+    /** Synthesized timestamp in Unix nanoseconds (bigint). */
+    timestamp: bigint;
+    /** Fraction of configured sources that responded (0.0–1.0). */
+    confidence: number;
+    /** Lowest NTP stratum observed across sources (2 for HTTPS Date headers). */
+    stratum: number;
+    /** Number of sources that successfully responded. */
+    sources: number;
+    /** Per-source readings used to compute the median. */
+    sourceReadings: {
+        source: string;
+        timestamp: bigint;
+        uncertainty: number;
+        stratum?: number;
+    }[];
+    /** Replay-protection nonce (hex). */
+    nonce: string;
+    /** Expiry timestamp in Unix milliseconds (bigint). */
+    expiresAt: bigint;
+    /** HMAC-SHA256 over canonical fields, hex-encoded. */
+    hmac: string;
+}
+export interface HttpPoTVerifyResult {
+    valid: boolean;
+    reason?: string;
+}
+export interface HttpOnlyClientOptions {
+    /**
+     * Override HMAC secret for non-sandbox usage.
+     * Defaults to a fixed sandbox key — sufficient for local verification only.
+     */
+    hmacSecret?: string;
+    /**
+     * Per-source request timeout in ms. Default: 3000.
+     */
+    timeoutMs?: number;
+    /**
+     * PoT validity window in seconds. Default: 60.
+     */
+    expirySeconds?: number;
+    /**
+     * Maximum divergence allowed between sources in nanoseconds.
+     * Default: 2_000_000_000n (2 seconds — lenient for HTTPS Date 1s resolution).
+     */
+    toleranceNs?: bigint;
+}
+/**
+ * HttpOnlyClient — zero-dependency Proof of Time over HTTPS.
+ *
+ * Fetches time from NIST, Apple, Google, and Cloudflare HTTPS endpoints,
+ * computes the median, and returns a PoT with HMAC integrity protection.
+ *
+ * No ETH, no signer, no on-chain interaction required.
+ */
+export declare class HttpOnlyClient {
+    private readonly hmacSecret;
+    private readonly timeoutMs;
+    private readonly expirySeconds;
+    private readonly toleranceNs;
+    private readonly usedNonces;
+    private readonly NONCE_TTL_MS;
+    private readonly MAX_NONCE_CACHE;
+    constructor(options?: HttpOnlyClientOptions);
+    /**
+     * Fetch time from all four HTTPS sources, compute median, return PoT.
+     * Requires at least 1 source to succeed.
+     */
+    generatePoT(): Promise<HttpPoT>;
+    /**
+     * Verify an HttpPoT:
+     * - HMAC integrity check
+     * - Expiry check
+     * - Nonce replay protection
+     * - Source divergence tolerance check
+     *
+     * No on-chain interaction. Pure local verification.
+     */
+    verifyPoT(pot: HttpPoT): HttpPoTVerifyResult;
+    /**
+     * Convert HttpPoT to the standard ProofOfTime shape used by the rest of the SDK.
+     * The issuerSignature field is omitted (no on-chain signer in httpOnly mode).
+     */
+    static toProofOfTime(pot: HttpPoT): ProofOfTime;
+}

package/dist/http_client.js

@@ -0,0 +1,252 @@
+"use strict";
+/**
+ * TTTClient.httpOnly() — Zero-friction Proof of Time
+ * No ETH, no signer, no on-chain. Just verified time.
+ *
+ * Usage:
+ *   const client = TTTClient.httpOnly();
+ *   const pot = await client.generatePoT();
+ *   console.log(pot.timestamp, pot.confidence);
+ *
+ * Time sources: NIST, Apple, Google, Cloudflare HTTPS Date headers.
+ * HMAC-SHA256 signature — no ethers.js dependency required.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpOnlyClient = void 0;
+const crypto = __importStar(require("crypto"));
+const https = __importStar(require("https"));
+const SOURCES = [
+    { name: "nist", url: "https://time.nist.gov/" },
+    { name: "apple", url: "https://time.apple.com/" },
+    { name: "google", url: "https://time.google.com/" },
+    { name: "cloudflare", url: "https://time.cloudflare.com/" },
+];
+function fetchHttpsDate(name, url, timeoutMs = 3000) {
+    return new Promise((resolve, reject) => {
+        const t1 = BigInt(Date.now()) * 1000000n;
+        const timer = setTimeout(() => {
+            req.destroy();
+            reject(new Error(`[httpOnly] Timeout: ${name} (${timeoutMs}ms)`));
+        }, timeoutMs);
+        const req = https.request(url, { method: "HEAD" }, (res) => {
+            clearTimeout(timer);
+            res.resume(); // drain so socket is freed
+            const t4 = BigInt(Date.now()) * 1000000n;
+            const dateHeader = res.headers["date"];
+            if (!dateHeader) {
+                reject(new Error(`[httpOnly] No Date header from ${name}`));
+                return;
+            }
+            const parsed = new Date(dateHeader).getTime();
+            if (isNaN(parsed)) {
+                reject(new Error(`[httpOnly] Invalid Date header from ${name}: ${dateHeader}`));
+                return;
+            }
+            const serverNs = BigInt(parsed) * 1000000n;
+            const rttNs = t4 - t1;
+            // Offset-corrected: server time + half RTT
+            const corrected = serverNs + rttNs / 2n;
+            const rttMs = Number(rttNs) / 1_000_000;
+            resolve({
+                source: name,
+                timestamp: corrected,
+                uncertainty: rttMs / 2 + 500, // 500ms base — HTTP Date has 1s resolution
+                stratum: 2,
+            });
+        });
+        req.on("error", (err) => {
+            clearTimeout(timer);
+            reject(new Error(`[httpOnly] Request error for ${name}: ${err.message}`));
+        });
+        req.end();
+    });
+}
+// ---------------------------------------------------------------------------
+// HMAC helpers — default sandbox key derived from fixed chain+address strings
+// ---------------------------------------------------------------------------
+const SANDBOX_HMAC_SECRET = "openttt-sandbox:chainId=0:address=0x0000000000000000000000000000000000000000";
+function computeHmac(timestamp, nonce, expiresAt, sources, secret = SANDBOX_HMAC_SECRET) {
+    // Canonical message: deterministic field concatenation
+    const msg = `${timestamp.toString()}:${nonce}:${expiresAt.toString()}:${sources}`;
+    return crypto.createHmac("sha256", secret).update(msg).digest("hex");
+}
+/**
+ * HttpOnlyClient — zero-dependency Proof of Time over HTTPS.
+ *
+ * Fetches time from NIST, Apple, Google, and Cloudflare HTTPS endpoints,
+ * computes the median, and returns a PoT with HMAC integrity protection.
+ *
+ * No ETH, no signer, no on-chain interaction required.
+ */
+class HttpOnlyClient {
+    hmacSecret;
+    timeoutMs;
+    expirySeconds;
+    toleranceNs;
+    usedNonces = new Map();
+    NONCE_TTL_MS = 300_000; // 5 min
+    MAX_NONCE_CACHE = 10_000;
+    constructor(options = {}) {
+        this.hmacSecret = options.hmacSecret ?? SANDBOX_HMAC_SECRET;
+        this.timeoutMs = options.timeoutMs ?? 3000;
+        this.expirySeconds = options.expirySeconds ?? 60;
+        this.toleranceNs = options.toleranceNs ?? 2000000000n; // 2 s
+    }
+    /**
+     * Fetch time from all four HTTPS sources, compute median, return PoT.
+     * Requires at least 1 source to succeed.
+     */
+    async generatePoT() {
+        const results = await Promise.allSettled(SOURCES.map((s) => fetchHttpsDate(s.name, s.url, this.timeoutMs)));
+        const readings = [];
+        for (const r of results) {
+            if (r.status === "fulfilled")
+                readings.push(r.value);
+        }
+        if (readings.length === 0) {
+            throw new Error("[httpOnly] All HTTPS time sources failed. Check network connectivity.");
+        }
+        // Sort by timestamp for median selection
+        readings.sort((a, b) => (a.timestamp < b.timestamp ? -1 : a.timestamp > b.timestamp ? 1 : 0));
+        let finalTs;
+        let finalUnc;
+        let finalStratum;
+        if (readings.length === 1) {
+            finalTs = readings[0].timestamp;
+            finalUnc = readings[0].uncertainty;
+            finalStratum = readings[0].stratum;
+        }
+        else if (readings.length === 2) {
+            finalTs = (readings[0].timestamp + readings[1].timestamp) / 2n;
+            finalUnc = (readings[0].uncertainty + readings[1].uncertainty) / 2;
+            finalStratum = Math.min(readings[0].stratum, readings[1].stratum);
+        }
+        else {
+            const mid = Math.floor(readings.length / 2);
+            finalTs = readings[mid].timestamp;
+            finalUnc = readings[mid].uncertainty;
+            finalStratum = readings[mid].stratum;
+        }
+        const nonce = crypto.randomBytes(16).toString("hex");
+        const expiresAt = BigInt(Date.now()) + BigInt(this.expirySeconds * 1000);
+        const sourceReadings = readings.map((r) => ({
+            source: r.source,
+            timestamp: r.timestamp,
+            uncertainty: r.uncertainty,
+            stratum: r.stratum,
+        }));
+        const hmac = computeHmac(finalTs, nonce, expiresAt, readings.length, this.hmacSecret);
+        return {
+            timestamp: finalTs,
+            confidence: readings.length / SOURCES.length,
+            stratum: finalStratum,
+            sources: readings.length,
+            sourceReadings,
+            nonce,
+            expiresAt,
+            hmac,
+        };
+    }
+    /**
+     * Verify an HttpPoT:
+     * - HMAC integrity check
+     * - Expiry check
+     * - Nonce replay protection
+     * - Source divergence tolerance check
+     *
+     * No on-chain interaction. Pure local verification.
+     */
+    verifyPoT(pot) {
+        // 1. Expiry
+        if (BigInt(Date.now()) > pot.expiresAt) {
+            return { valid: false, reason: "PoT expired" };
+        }
+        // 2. HMAC integrity
+        const expected = computeHmac(pot.timestamp, pot.nonce, pot.expiresAt, pot.sources, this.hmacSecret);
+        if (!crypto.timingSafeEqual(Buffer.from(expected, "hex"), Buffer.from(pot.hmac, "hex"))) {
+            return { valid: false, reason: "HMAC mismatch — PoT may have been tampered" };
+        }
+        // 3. Nonce replay (bounded cache + TTL)
+        const now = Date.now();
+        if (this.usedNonces.size > this.MAX_NONCE_CACHE / 2) {
+            for (const [k, ts] of this.usedNonces) {
+                if (now - ts > this.NONCE_TTL_MS)
+                    this.usedNonces.delete(k);
+            }
+        }
+        if (this.usedNonces.has(pot.nonce)) {
+            return { valid: false, reason: "Duplicate nonce — replay detected" };
+        }
+        if (this.usedNonces.size >= this.MAX_NONCE_CACHE) {
+            const oldest = this.usedNonces.keys().next().value;
+            if (oldest !== undefined)
+                this.usedNonces.delete(oldest);
+        }
+        this.usedNonces.set(pot.nonce, now);
+        // 4. Source divergence
+        for (const reading of pot.sourceReadings) {
+            const diff = reading.timestamp > pot.timestamp
+                ? reading.timestamp - pot.timestamp
+                : pot.timestamp - reading.timestamp;
+            if (diff > this.toleranceNs) {
+                return {
+                    valid: false,
+                    reason: `Source ${reading.source} diverges by ${diff}ns (tolerance: ${this.toleranceNs}ns)`,
+                };
+            }
+        }
+        return { valid: true };
+    }
+    /**
+     * Convert HttpPoT to the standard ProofOfTime shape used by the rest of the SDK.
+     * The issuerSignature field is omitted (no on-chain signer in httpOnly mode).
+     */
+    static toProofOfTime(pot) {
+        return {
+            timestamp: pot.timestamp,
+            uncertainty: pot.sourceReadings.length > 0
+                ? pot.sourceReadings.reduce((sum, r) => sum + r.uncertainty, 0) / pot.sourceReadings.length
+                : 500,
+            sources: pot.sources,
+            stratum: pot.stratum,
+            confidence: pot.confidence,
+            sourceReadings: pot.sourceReadings,
+            nonce: pot.nonce,
+            expiresAt: pot.expiresAt,
+        };
+    }
+}
+exports.HttpOnlyClient = HttpOnlyClient;

package/dist/index.d.ts

@@ -1,5 +1,4 @@
-export * from "./grg_forward";
-export * from "./grg_inverse";
+export * from "../vendor/helm-crypto";
 export * from "./adaptive_switch";
 export * from "./evm_connector";
 export * from "./x402_enforcer";
@@ -10,13 +9,14 @@ export * from "./v4_hook";
 export * from "./logger";
 export * from "./types";
 export * from "./ttt_client";
+export * from "./http_client";
 export * from "./auto_mint";
 export * from "./time_synthesis";
 export * from "./dynamic_fee";
-export * from "./golay";
-export * from "./grg_pipeline";
 export * from "./signer";
 export * from "./networks";
-export * from "./reed_solomon";
 export * from "./errors";
 export * from "./pot_signer";
+export * from "./ct_log";
+export * from "./trust_store";
+export * from "./revenue_tiers";

package/dist/index.js

@@ -15,8 +15,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 // sdk/src/index.ts
-__exportStar(require("./grg_forward"), exports);
-__exportStar(require("./grg_inverse"), exports);
+__exportStar(require("../vendor/helm-crypto"), exports);
 __exportStar(require("./adaptive_switch"), exports);
 __exportStar(require("./evm_connector"), exports);
 __exportStar(require("./x402_enforcer"), exports);
@@ -27,13 +26,14 @@ __exportStar(require("./v4_hook"), exports);
 __exportStar(require("./logger"), exports);
 __exportStar(require("./types"), exports);
 __exportStar(require("./ttt_client"), exports);
+__exportStar(require("./http_client"), exports);
 __exportStar(require("./auto_mint"), exports);
 __exportStar(require("./time_synthesis"), exports);
 __exportStar(require("./dynamic_fee"), exports);
-__exportStar(require("./golay"), exports);
-__exportStar(require("./grg_pipeline"), exports);
 __exportStar(require("./signer"), exports);
 __exportStar(require("./networks"), exports);
-__exportStar(require("./reed_solomon"), exports);
 __exportStar(require("./errors"), exports);
 __exportStar(require("./pot_signer"), exports);
+__exportStar(require("./ct_log"), exports);
+__exportStar(require("./trust_store"), exports);
+__exportStar(require("./revenue_tiers"), exports);

package/dist/logger.d.ts

@@ -1,18 +1,50 @@
 export declare enum LogLevel {
-    INFO = "INFO",
-    WARN = "WARN",
-    ERROR = "ERROR",
-    DEBUG = "DEBUG"
+    DEBUG = 0,
+    INFO = 1,
+    WARN = 2,
+    ERROR = 3,
+    SILENT = 4
+}
+/**
+ * Custom log handler function type.
+ * @param level - The severity level of the log message.
+ * @param message - The formatted log message string.
+ */
+export type LogHandler = (level: LogLevel, message: string) => void;
+interface LoggerConfig {
+    level?: LogLevel;
+    handler?: LogHandler;
 }
 export declare class Logger {
     private static instance;
+    private static currentLevel;
+    private static currentHandler;
     private namespace;
     private constructor();
     static getInstance(namespace?: string): Logger;
+    /**
+     * Configure the global logger level and/or handler.
+     * @param config - Configuration object with optional level and handler.
+     *
+     * @example
+     * ```typescript
+     * Logger.configure({ level: LogLevel.DEBUG });
+     * Logger.configure({ handler: (level, msg) => myLogService.send(msg) });
+     * Logger.configure({ level: LogLevel.WARN, handler: customHandler });
+     * ```
+     */
+    static configure(config: LoggerConfig): void;
+    /**
+     * Convenience method to suppress all log output.
+     * Equivalent to `Logger.configure({ level: LogLevel.SILENT })`.
+     */
+    static silent(): void;
     private formatMessage;
+    private emit;
     info(message: string): void;
     warn(message: string): void;
     error(message: string, error?: Error): void;
     debug(message: string): void;
 }
 export declare const logger: Logger;
+export {};

package/dist/logger.js

@@ -4,13 +4,42 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.logger = exports.Logger = exports.LogLevel = void 0;
 var LogLevel;
 (function (LogLevel) {
-    LogLevel["INFO"] = "INFO";
-    LogLevel["WARN"] = "WARN";
-    LogLevel["ERROR"] = "ERROR";
-    LogLevel["DEBUG"] = "DEBUG";
+    LogLevel[LogLevel["DEBUG"] = 0] = "DEBUG";
+    LogLevel[LogLevel["INFO"] = 1] = "INFO";
+    LogLevel[LogLevel["WARN"] = 2] = "WARN";
+    LogLevel[LogLevel["ERROR"] = 3] = "ERROR";
+    LogLevel[LogLevel["SILENT"] = 4] = "SILENT";
 })(LogLevel || (exports.LogLevel = LogLevel = {}));
+const LOG_LEVEL_NAMES = {
+    [LogLevel.DEBUG]: "DEBUG",
+    [LogLevel.INFO]: "INFO",
+    [LogLevel.WARN]: "WARN",
+    [LogLevel.ERROR]: "ERROR",
+    [LogLevel.SILENT]: "SILENT",
+};
+/**
+ * Default log handler that writes to the console.
+ */
+const defaultHandler = (level, message) => {
+    switch (level) {
+        case LogLevel.DEBUG:
+            console.debug(message);
+            break;
+        case LogLevel.INFO:
+            console.log(message);
+            break;
+        case LogLevel.WARN:
+            console.warn(message);
+            break;
+        case LogLevel.ERROR:
+            console.error(message);
+            break;
+    }
+};
 class Logger {
     static instance;
+    static currentLevel = LogLevel.INFO;
+    static currentHandler = defaultHandler;
     namespace;
     constructor(namespace = "TTT-SDK") {
         this.namespace = namespace;
@@ -21,15 +50,47 @@ class Logger {
         }
         return Logger.instance;
     }
+    /**
+     * Configure the global logger level and/or handler.
+     * @param config - Configuration object with optional level and handler.
+     *
+     * @example
+     * ```typescript
+     * Logger.configure({ level: LogLevel.DEBUG });
+     * Logger.configure({ handler: (level, msg) => myLogService.send(msg) });
+     * Logger.configure({ level: LogLevel.WARN, handler: customHandler });
+     * ```
+     */
+    static configure(config) {
+        if (config.level !== undefined) {
+            Logger.currentLevel = config.level;
+        }
+        if (config.handler !== undefined) {
+            Logger.currentHandler = config.handler;
+        }
+    }
+    /**
+     * Convenience method to suppress all log output.
+     * Equivalent to `Logger.configure({ level: LogLevel.SILENT })`.
+     */
+    static silent() {
+        Logger.currentLevel = LogLevel.SILENT;
+    }
     formatMessage(level, message) {
         const timestamp = new Date().toISOString();
-        return `[${timestamp}] [${level}] [${this.namespace}] ${message}`;
+        return `[${timestamp}] [${LOG_LEVEL_NAMES[level]}] [${this.namespace}] ${message}`;
+    }
+    emit(level, message) {
+        if (level < Logger.currentLevel)
+            return;
+        const formatted = this.formatMessage(level, message);
+        Logger.currentHandler(level, formatted);
     }
     info(message) {
-        console.log(this.formatMessage(LogLevel.INFO, message));
+        this.emit(LogLevel.INFO, message);
     }
     warn(message) {
-        console.warn(this.formatMessage(LogLevel.WARN, message));
+        this.emit(LogLevel.WARN, message);
     }
     error(message, error) {
         let msg = message;
@@ -39,12 +100,10 @@ class Logger {
                 msg += `\nStack: ${error.stack}`;
             }
         }
-        console.error(this.formatMessage(LogLevel.ERROR, msg));
+        this.emit(LogLevel.ERROR, msg);
     }
     debug(message) {
-        if (process.env.DEBUG) {
-            console.debug(this.formatMessage(LogLevel.DEBUG, message));
-        }
+        this.emit(LogLevel.DEBUG, message);
     }
 }
 exports.Logger = Logger;

package/dist/networks.d.ts

@@ -8,6 +8,27 @@ export interface NetworkConfig {
     protocolFeeAddress: string;
     usdcAddress: string;
 }
+/**
+ * Base Mainnet network preset.
+ *
+ * `tttAddress` and `protocolFeeAddress` are set to the zero address because the
+ * TTT contracts have not yet been deployed to Base Mainnet. These are
+ * placeholders only — using them without an override will cause a runtime error
+ * (validated in `TTTClient.create`).
+ *
+ * **Operators deploying to mainnet** must supply their own `contractAddress` and
+ * `feeCollectorAddress` via `TTTClientConfig` when calling `TTTClient.create()`.
+ * Example:
+ * ```ts
+ * const client = await TTTClient.create({
+ *   network: "base",
+ *   contractAddress: "0xYourDeployedTTTContract",
+ *   feeCollectorAddress: "0xYourFeeCollector",
+ *   // ...other config
+ * });
+ * ```
+ */
 export declare const BASE_MAINNET: NetworkConfig;
+export declare const ETH_SEPOLIA: NetworkConfig;
 export declare const BASE_SEPOLIA: NetworkConfig;
 export declare const NETWORKS: Record<string, NetworkConfig>;

package/dist/networks.js

@@ -1,8 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.NETWORKS = exports.BASE_SEPOLIA = exports.BASE_MAINNET = void 0;
-// ⚠️ MAINNET ADDRESSES NOT YET DEPLOYED — must be overridden via TTTClientConfig.contractAddress
-// Using these defaults without override will throw at runtime (validated in TTTClient.create)
+exports.NETWORKS = exports.BASE_SEPOLIA = exports.ETH_SEPOLIA = exports.BASE_MAINNET = void 0;
+/**
+ * Base Mainnet network preset.
+ *
+ * `tttAddress` and `protocolFeeAddress` are set to the zero address because the
+ * TTT contracts have not yet been deployed to Base Mainnet. These are
+ * placeholders only — using them without an override will cause a runtime error
+ * (validated in `TTTClient.create`).
+ *
+ * **Operators deploying to mainnet** must supply their own `contractAddress` and
+ * `feeCollectorAddress` via `TTTClientConfig` when calling `TTTClient.create()`.
+ * Example:
+ * ```ts
+ * const client = await TTTClient.create({
+ *   network: "base",
+ *   contractAddress: "0xYourDeployedTTTContract",
+ *   feeCollectorAddress: "0xYourFeeCollector",
+ *   // ...other config
+ * });
+ * ```
+ */
 exports.BASE_MAINNET = {
     chainId: 8453,
     rpcUrl: "https://mainnet.base.org",
@@ -10,6 +28,13 @@ exports.BASE_MAINNET = {
     protocolFeeAddress: "0x0000000000000000000000000000000000000000",
     usdcAddress: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
 };
+exports.ETH_SEPOLIA = {
+    chainId: 11155111,
+    rpcUrl: "https://ethereum-sepolia-rpc.publicnode.com",
+    tttAddress: "0x291b83F605F2dA95cf843d4a53983B413ef3B929",
+    protocolFeeAddress: "0x6b39D96741BB4Ce6283F824CC31c2931c75AEe64",
+    usdcAddress: "0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238",
+};
 exports.BASE_SEPOLIA = {
     chainId: 84532,
     rpcUrl: "https://sepolia.base.org",
@@ -19,5 +44,6 @@ exports.BASE_SEPOLIA = {
 };
 exports.NETWORKS = {
     base: exports.BASE_MAINNET,
-    sepolia: exports.BASE_SEPOLIA,
+    sepolia: exports.ETH_SEPOLIA,
+    baseSepolia: exports.BASE_SEPOLIA,
 };

package/dist/pool_registry.d.ts

@@ -55,4 +55,13 @@ export declare class PoolRegistry {
      * @returns Array of pool addresses.
      */
     listPools(): string[];
+    /**
+     * Serialize registry state to JSON for persistence across restarts.
+     * Allows operators to restore pool registrations and stats without re-registering.
+     */
+    serialize(): string;
+    /**
+     * Reconstruct a PoolRegistry from previously serialized JSON state.
+     */
+    static deserialize(json: string): PoolRegistry;
 }