openttt 0.1.2 → 0.1.3

package/dist/evm_connector.js

@@ -14,14 +14,22 @@ class EVMConnector {
     eventListeners = []; // P2-6: Track listeners for cleanup
     // P1-7: Timeout wrapper for gas estimation
     static GAS_TIMEOUT_MS = 5000;
-    constructor() { }
+    primaryRpcUrl = "";
+    fallbackRpcUrls = [];
+    signerOrKey = null;
+    maxReconnectAttempts;
+    connected = false;
+    constructor(options) {
+        this.fallbackRpcUrls = options?.fallbackRpcUrls ?? [];
+        this.maxReconnectAttempts = options?.maxReconnectAttempts ?? 3;
+    }
     /**
      * P1-7: Race estimateGas against timeout to prevent DoS
      */
     async withTimeout(promise, ms = EVMConnector.GAS_TIMEOUT_MS) {
         return Promise.race([
             promise,
-            new Promise((_, reject) => setTimeout(() => reject(new errors_1.TTTNetworkError(`[EVM] Operation timed out`, `RPC did not respond within ${ms}ms`, `Check your RPC provider status or increase timeout.`)), ms))
+            new Promise((_, reject) => setTimeout(() => reject(new errors_1.TTTNetworkError(errors_1.ERROR_CODES.NETWORK_CONNECTION_FAILED, `[EVM] Operation timed out`, `RPC did not respond within ${ms}ms`, `Check your RPC provider status or increase timeout.`)), ms))
         ]);
     }
     /**
@@ -29,36 +37,116 @@ class EVMConnector {
      */
     async connect(rpcUrl, signerOrKey) {
         if (!rpcUrl || typeof rpcUrl !== "string")
-            throw new errors_1.TTTNetworkError("[EVM] Invalid RPC URL", "The provided RPC URL is empty or not a string", "Pass a valid RPC URL (e.g., https://mainnet.base.org)");
+            throw new errors_1.TTTNetworkError(errors_1.ERROR_CODES.NETWORK_INVALID_RPC, "[EVM] Invalid RPC URL", "The provided RPC URL is empty or not a string", "Pass a valid RPC URL (e.g., https://mainnet.base.org)");
+        this.primaryRpcUrl = rpcUrl;
+        this.signerOrKey = signerOrKey;
         try {
             this.provider = new ethers_1.JsonRpcProvider(rpcUrl);
             if (typeof signerOrKey === "string") {
                 if (!signerOrKey.startsWith("0x") || signerOrKey.length !== 66) {
-                    throw new errors_1.TTTContractError("[EVM] Invalid Private Key format", "Private key must be 0x + 64 hex characters", "Provide a valid 32-byte hex private key.");
+                    throw new errors_1.TTTContractError(errors_1.ERROR_CODES.CONTRACT_INVALID_KEY_FORMAT, "[EVM] Invalid Private Key format", "Private key must be 0x + 64 hex characters", "Provide a valid 32-byte hex private key.");
                 }
                 this.signer = new ethers_1.ethers.Wallet(signerOrKey, this.provider);
             }
             else {
-                // Signer might already be connected to a provider, but we ensure it's linked to ours
                 this.signer = signerOrKey.connect ? signerOrKey.connect(this.provider) : signerOrKey;
             }
             const network = await this.provider.getNetwork();
+            this.connected = true;
             logger_1.logger.info(`[EVM] Connected to Chain ID: ${network.chainId}`);
         }
         catch (error) {
             if (error instanceof errors_1.TTTContractError || error instanceof errors_1.TTTNetworkError)
                 throw error;
-            throw new errors_1.TTTNetworkError(`[EVM] Connection failed`, error instanceof Error ? error.message : String(error), `Verify your RPC URL and network connectivity.`);
+            // Try fallback RPCs before giving up
+            for (const fallback of this.fallbackRpcUrls) {
+                try {
+                    logger_1.logger.warn(`[EVM] Primary RPC failed, trying fallback: ${fallback}`);
+                    this.provider = new ethers_1.JsonRpcProvider(fallback);
+                    if (typeof signerOrKey === "string") {
+                        this.signer = new ethers_1.ethers.Wallet(signerOrKey, this.provider);
+                    }
+                    else {
+                        this.signer = signerOrKey.connect ? signerOrKey.connect(this.provider) : signerOrKey;
+                    }
+                    const network = await this.provider.getNetwork();
+                    this.connected = true;
+                    logger_1.logger.info(`[EVM] Connected via fallback to Chain ID: ${network.chainId}`);
+                    return;
+                }
+                catch {
+                    continue;
+                }
+            }
+            throw new errors_1.TTTNetworkError(errors_1.ERROR_CODES.NETWORK_CONNECTION_FAILED, `[EVM] Connection failed`, error instanceof Error ? error.message : String(error), `Verify your RPC URL and network connectivity.`);
+        }
+    }
+    /**
+     * Reconnect using stored credentials. Tries primary first, then fallbacks.
+     */
+    async reconnect() {
+        if (!this.signerOrKey)
+            throw new errors_1.TTTNetworkError(errors_1.ERROR_CODES.NETWORK_CANNOT_RECONNECT, "[EVM] Cannot reconnect", "No previous connection credentials stored", "Call connect() first.");
+        this.disconnect();
+        const allUrls = [this.primaryRpcUrl, ...this.fallbackRpcUrls].filter(Boolean);
+        for (let attempt = 0; attempt < Math.min(this.maxReconnectAttempts, allUrls.length); attempt++) {
+            try {
+                const url = allUrls[attempt % allUrls.length];
+                logger_1.logger.info(`[EVM] Reconnect attempt ${attempt + 1}/${this.maxReconnectAttempts} → ${url}`);
+                this.provider = new ethers_1.JsonRpcProvider(url);
+                if (typeof this.signerOrKey === "string") {
+                    this.signer = new ethers_1.ethers.Wallet(this.signerOrKey, this.provider);
+                }
+                else {
+                    this.signer = this.signerOrKey.connect ? this.signerOrKey.connect(this.provider) : this.signerOrKey;
+                }
+                await this.provider.getNetwork();
+                this.connected = true;
+                logger_1.logger.info(`[EVM] Reconnected successfully`);
+                return;
+            }
+            catch {
+                logger_1.logger.warn(`[EVM] Reconnect attempt ${attempt + 1} failed`);
+            }
+        }
+        this.connected = false;
+        throw new errors_1.TTTNetworkError(errors_1.ERROR_CODES.NETWORK_RECONNECTION_EXHAUSTED, "[EVM] Reconnection failed", `All ${this.maxReconnectAttempts} attempts exhausted`, "Check RPC provider status and network connectivity.");
+    }
+    /**
+     * Disconnect and release all resources.
+     */
+    disconnect() {
+        this.unsubscribeAll();
+        if (this.provider) {
+            this.provider.destroy();
         }
+        this.provider = null;
+        this.signer = null;
+        this.tttContract = null;
+        this.protocolFeeContract = null;
+        this.connected = false;
+        logger_1.logger.info("[EVM] Disconnected and resources released");
+    }
+    /**
+     * Check if the connector is currently connected.
+     */
+    isConnected() {
+        return this.connected && this.provider !== null;
     }
+    /**
+     * CT Log Equivalent: PoTAnchored event ABI fragment.
+     * Every Proof-of-Time anchor is publicly auditable on-chain,
+     * analogous to Certificate Transparency logs in TLS.
+     */
+    static POT_ANCHORED_EVENT_ABI = "event PoTAnchored(uint64 indexed timestamp, bytes32 grgHash, uint8 stratum, bytes32 potHash)";
     /**
      * Attach the TTT Token contract.
      */
     attachContract(address, abi) {
         if (!this.signer)
-            throw new errors_1.TTTContractError("Not connected to signer", "EVMConnector.connect() must be called first", "Initialize connection before attaching contracts.");
+            throw new errors_1.TTTContractError(errors_1.ERROR_CODES.CONTRACT_SIGNER_NOT_CONNECTED, "Not connected to signer", "EVMConnector.connect() must be called first", "Initialize connection before attaching contracts.");
         if (!address || !ethers_1.ethers.isAddress(address))
-            throw new errors_1.TTTContractError(`[EVM] Invalid contract address`, `Address '${address}' is not a valid EVM address`, `Check your config and provide a valid checksummed address.`);
+            throw new errors_1.TTTContractError(errors_1.ERROR_CODES.CONTRACT_INVALID_ADDRESS, `[EVM] Invalid contract address`, `Address '${address}' is not a valid EVM address`, `Check your config and provide a valid checksummed address.`);
         this.tttContract = new ethers_1.Contract(address, abi, this.signer);
     }
     /**
@@ -66,9 +154,9 @@ class EVMConnector {
      */
     attachProtocolFeeContract(address, abi) {
         if (!this.signer)
-            throw new errors_1.TTTContractError("Not connected to signer", "EVMConnector.connect() must be called first", "Initialize connection before attaching contracts.");
+            throw new errors_1.TTTContractError(errors_1.ERROR_CODES.CONTRACT_SIGNER_NOT_CONNECTED, "Not connected to signer", "EVMConnector.connect() must be called first", "Initialize connection before attaching contracts.");
         if (!address || !ethers_1.ethers.isAddress(address))
-            throw new errors_1.TTTContractError(`[EVM] Invalid contract address`, `Address '${address}' is not a valid EVM address`, `Check your config and provide a valid checksummed address.`);
+            throw new errors_1.TTTContractError(errors_1.ERROR_CODES.CONTRACT_INVALID_ADDRESS, `[EVM] Invalid contract address`, `Address '${address}' is not a valid EVM address`, `Check your config and provide a valid checksummed address.`);
         this.protocolFeeContract = new ethers_1.Contract(address, abi, this.signer);
     }
     /**
@@ -76,7 +164,7 @@ class EVMConnector {
      */
     async submitTTTRecord(record, amount, tier) {
         if (!this.tttContract)
-            throw new errors_1.TTTContractError("Contract not attached", "TTT contract instance is null", "Call attachContract() with valid TTT address before burning.");
+            throw new errors_1.TTTContractError(errors_1.ERROR_CODES.CONTRACT_NOT_ATTACHED, "Contract not attached", "TTT contract instance is null", "Call attachContract() with valid TTT address before burning.");
         const grgHash = ethers_1.ethers.keccak256(ethers_1.ethers.concat(record.grgPayload));
         try {
             // P1-7: Gas estimation with timeout
@@ -88,14 +176,14 @@ class EVMConnector {
             const receipt = await tx.wait();
             // P2-5: Null check for dropped transactions
             if (!receipt)
-                throw new errors_1.TTTNetworkError(`[EVM] Transaction failed`, `Transaction was dropped from mempool or null receipt`, `Check block explorer for tx status.`);
+                throw new errors_1.TTTNetworkError(errors_1.ERROR_CODES.NETWORK_TX_DROPPED, `[EVM] Transaction failed`, `Transaction was dropped from mempool or null receipt`, `Check block explorer for tx status.`);
             return receipt;
         }
         catch (error) {
             if (error instanceof errors_1.TTTNetworkError || error instanceof errors_1.TTTContractError)
                 throw error;
             const reason = this.extractRevertReason(error);
-            throw new errors_1.TTTContractError(`[EVM] Burn failed`, reason, `Verify your TTT balance and tier parameters.`);
+            throw new errors_1.TTTContractError(errors_1.ERROR_CODES.CONTRACT_BURN_FAILED, `[EVM] Burn failed`, reason, `Verify your TTT balance and tier parameters.`);
         }
     }
     /**
@@ -103,22 +191,26 @@ class EVMConnector {
      */
     async mintTTT(to, amount, grgHash, potHash) {
         if (!this.tttContract)
-            throw new errors_1.TTTContractError("Contract not attached", "TTT contract instance is null", "Call attachContract() before minting.");
+            throw new errors_1.TTTContractError(errors_1.ERROR_CODES.CONTRACT_NOT_ATTACHED, "Contract not attached", "TTT contract instance is null", "Call attachContract() before minting.");
         if (!to || !ethers_1.ethers.isAddress(to))
-            throw new errors_1.TTTContractError(`[EVM] Invalid recipient address`, `Address '${to}' is not a valid EVM address`, `Provide a valid destination address.`);
+            throw new errors_1.TTTContractError(errors_1.ERROR_CODES.CONTRACT_INVALID_ADDRESS, `[EVM] Invalid recipient address`, `Address '${to}' is not a valid EVM address`, `Provide a valid destination address.`);
         try {
             if (potHash) {
                 logger_1.logger.info(`[EVM] Recording PoT fingerprint: ${potHash}`);
             }
-            const tx = await this.tttContract.mint(to, amount, grgHash);
+            // Gas estimation with 20% buffer and timeout (matching burnTTT pattern)
+            const gasLimit = await this.withTimeout(this.tttContract.mint.estimateGas(to, amount, grgHash));
+            const tx = await this.tttContract.mint(to, amount, grgHash, {
+                gasLimit: (gasLimit * 120n) / 100n
+            });
             const receipt = await tx.wait();
             if (!receipt)
-                throw new errors_1.TTTNetworkError(`[EVM] Mint TX dropped`, `Transaction was dropped from mempool`, `Check operator account for nonce collisions.`);
+                throw new errors_1.TTTNetworkError(errors_1.ERROR_CODES.NETWORK_TX_DROPPED, `[EVM] Mint TX dropped`, `Transaction was dropped from mempool`, `Check operator account for nonce collisions.`);
             return receipt;
         }
         catch (error) {
             const reason = this.extractRevertReason(error);
-            throw new errors_1.TTTContractError(`[EVM] Mint failed`, reason, `Ensure operator has minter role and sufficient gas.`);
+            throw new errors_1.TTTContractError(errors_1.ERROR_CODES.CONTRACT_MINT_FAILED, `[EVM] Mint failed`, reason, `Ensure operator has minter role and sufficient gas.`);
         }
     }
     /**
@@ -126,17 +218,17 @@ class EVMConnector {
      */
     async burnTTT(amount, grgHash, tierLevel) {
         if (!this.tttContract)
-            throw new errors_1.TTTContractError("Contract not attached", "TTT contract instance is null", "Call attachContract() before burning.");
+            throw new errors_1.TTTContractError(errors_1.ERROR_CODES.CONTRACT_NOT_ATTACHED, "Contract not attached", "TTT contract instance is null", "Call attachContract() before burning.");
         try {
             const tx = await this.tttContract.burn(amount, grgHash, tierLevel);
             const receipt = await tx.wait();
             if (!receipt)
-                throw new errors_1.TTTNetworkError(`[EVM] Burn TX dropped`, `Transaction was dropped from mempool`, `Verify account balance.`);
+                throw new errors_1.TTTNetworkError(errors_1.ERROR_CODES.NETWORK_TX_DROPPED, `[EVM] Burn TX dropped`, `Transaction was dropped from mempool`, `Verify account balance.`);
             return { hash: receipt.hash };
         }
         catch (error) {
             const reason = this.extractRevertReason(error);
-            throw new errors_1.TTTContractError(`[EVM] Burn failed`, reason, `Check TTT balance.`);
+            throw new errors_1.TTTContractError(errors_1.ERROR_CODES.CONTRACT_BURN_FAILED, `[EVM] Burn failed`, reason, `Check TTT balance.`);
         }
     }
     /**
@@ -144,13 +236,13 @@ class EVMConnector {
      */
     async getTTTBalance(user, tokenId) {
         if (!this.tttContract)
-            throw new errors_1.TTTContractError("Contract not attached", "TTT contract instance is null", "Call attachContract() before querying balance.");
+            throw new errors_1.TTTContractError(errors_1.ERROR_CODES.CONTRACT_NOT_ATTACHED, "Contract not attached", "TTT contract instance is null", "Call attachContract() before querying balance.");
         try {
             return await this.tttContract.balanceOf(user, tokenId);
         }
         catch (error) {
             const reason = this.extractRevertReason(error);
-            throw new errors_1.TTTContractError(`[EVM] Balance query failed`, reason, `Check RPC connection and contract address.`);
+            throw new errors_1.TTTContractError(errors_1.ERROR_CODES.CONTRACT_BALANCE_QUERY_FAILED, `[EVM] Balance query failed`, reason, `Check RPC connection and contract address.`);
         }
     }
     /**
@@ -158,9 +250,9 @@ class EVMConnector {
      */
     async swap(routerAddress, tokenIn, tokenOut, amountIn, minAmountOut) {
         if (!this.signer)
-            throw new errors_1.TTTContractError("Not connected to signer", "Signer is null", "Initialize connection.");
+            throw new errors_1.TTTContractError(errors_1.ERROR_CODES.CONTRACT_SIGNER_NOT_CONNECTED, "Not connected to signer", "Signer is null", "Initialize connection.");
         if (!routerAddress || !ethers_1.ethers.isAddress(routerAddress))
-            throw new errors_1.TTTContractError(`[EVM] Invalid router address`, `Address '${routerAddress}' is invalid`, `Provide valid V4 SwapRouter address.`);
+            throw new errors_1.TTTContractError(errors_1.ERROR_CODES.CONTRACT_INVALID_ADDRESS, `[EVM] Invalid router address`, `Address '${routerAddress}' is invalid`, `Provide valid V4 SwapRouter address.`);
         logger_1.logger.info(`[EVM] Swapping ${amountIn} of ${tokenIn} for ${tokenOut} via ${routerAddress}`);
         // Realistic Uniswap V4-like SwapRouter ABI for simulation/integration
         const swapRouterAbi = [
@@ -176,14 +268,14 @@ class EVMConnector {
             logger_1.logger.info(`[EVM] Swap TX Sent: ${tx.hash}`);
             const receipt = await tx.wait();
             if (!receipt)
-                throw new errors_1.TTTNetworkError(`[EVM] Swap TX dropped`, `Transaction dropped`, `Check gas price.`);
+                throw new errors_1.TTTNetworkError(errors_1.ERROR_CODES.NETWORK_TX_DROPPED, `[EVM] Swap TX dropped`, `Transaction dropped`, `Check gas price.`);
             return receipt;
         }
         catch (error) {
             if (error instanceof errors_1.TTTNetworkError || error instanceof errors_1.TTTContractError)
                 throw error;
             const reason = this.extractRevertReason(error);
-            throw new errors_1.TTTContractError(`[EVM] Swap failed`, reason, `Verify slippage and token balances.`);
+            throw new errors_1.TTTContractError(errors_1.ERROR_CODES.CONTRACT_SWAP_FAILED, `[EVM] Swap failed`, reason, `Verify slippage and token balances.`);
         }
     }
     /**
@@ -241,10 +333,10 @@ class EVMConnector {
      */
     async verifyBlock(blockNum) {
         if (!this.provider)
-            throw new errors_1.TTTNetworkError("Provider not connected", "RPC provider is null", "Call connect() first.");
+            throw new errors_1.TTTNetworkError(errors_1.ERROR_CODES.NETWORK_PROVIDER_NOT_CONNECTED, "Provider not connected", "RPC provider is null", "Call connect() first.");
         const block = await this.provider.getBlock(blockNum);
         if (!block)
-            throw new errors_1.TTTNetworkError(`Block not found`, `RPC returned null for block ${blockNum}`, `Verify if block number exists on chain.`);
+            throw new errors_1.TTTNetworkError(errors_1.ERROR_CODES.NETWORK_BLOCK_NOT_FOUND, `Block not found`, `RPC returned null for block ${blockNum}`, `Verify if block number exists on chain.`);
         return {
             valid: true,
             blockNumber: blockNum,
@@ -258,7 +350,7 @@ class EVMConnector {
      */
     async getPendingTransactions() {
         if (!this.provider)
-            throw new errors_1.TTTNetworkError("Provider not connected", "RPC provider is null", "Call connect() first.");
+            throw new errors_1.TTTNetworkError(errors_1.ERROR_CODES.NETWORK_PROVIDER_NOT_CONNECTED, "Provider not connected", "RPC provider is null", "Call connect() first.");
         const block = await this.provider.send("eth_getBlockByNumber", ["pending", false]);
         return block ? block.transactions : [];
     }
@@ -267,7 +359,7 @@ class EVMConnector {
      */
     getProvider() {
         if (!this.provider)
-            throw new errors_1.TTTNetworkError("Provider not connected", "RPC provider is null", "Call connect() first.");
+            throw new errors_1.TTTNetworkError(errors_1.ERROR_CODES.NETWORK_PROVIDER_NOT_CONNECTED, "Provider not connected", "RPC provider is null", "Call connect() first.");
         return this.provider;
     }
     /**
@@ -275,7 +367,7 @@ class EVMConnector {
      */
     getSigner() {
         if (!this.signer)
-            throw new errors_1.TTTContractError("Signer not connected", "Signer is null", "Call connect() first.");
+            throw new errors_1.TTTContractError(errors_1.ERROR_CODES.CONTRACT_SIGNER_NOT_CONNECTED, "Signer not connected", "Signer is null", "Call connect() first.");
         return this.signer;
     }
     /**

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";
@@ -13,10 +12,10 @@ export * from "./ttt_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);
@@ -30,10 +29,10 @@ __exportStar(require("./ttt_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;
 }